@r2wa-org/eden 0.0.56 → 0.0.57

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

@@ -1,4 +1,3 @@
-import { createAuthMiddleware } from "better-auth/plugins";
 import * as roles from "./roles";
 /**
  * 显式类型注解绕过 TS2742（AnonymousOptions 未从 better-auth/plugins 公共入口导出）
@@ -35,7 +34,7 @@ export declare const auth: import("better-auth").Auth<{
         };
     };
     hooks: {
-        before: (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<void>;
+        before: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<void>;
     };
     emailAndPassword: {
         enabled: true;
@@ -74,19 +73,43 @@ export declare const auth: import("better-auth").Auth<{
     disablePaths: string[];
     appName: string;
     plugins: [{
-        id: string;
+        id: "i18n";
+        version: string;
         hooks: {
-            after: Array<{
-                matcher: (ctx: any) => boolean;
-                handler: ReturnType<typeof createAuthMiddleware>;
-            }>;
+            after: {
+                matcher: () => true;
+                handler: (inputContext: {
+                    body?: undefined;
+                } & {
+                    query?: Record<string, any> | undefined;
+                } & {
+                    request?: Request;
+                } & {
+                    headers?: HeadersInit;
+                } & {
+                    asResponse?: boolean;
+                    returnHeaders?: boolean;
+                    use?: any[];
+                }) => Promise<void>;
+            }[];
+        };
+        options: {
+            translations: {
+                [x: string]: import("@better-auth/i18n").TranslationDictionary;
+            };
+            defaultLocale: string;
+            detection: import("@better-auth/i18n").LocaleDetectionStrategy[];
+            localeCookie: string;
+            userLocaleField: string;
+            getLocale?: ((ctx: import("better-auth").GenericEndpointContext) => string | Promise<string | null> | null) | undefined;
         };
     }, {
         id: "bearer";
+        version: string;
         hooks: {
             before: {
                 matcher(context: import("better-auth").HookEndpointContext): boolean;
-                handler: (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
                     context: {
                         headers: Headers;
                     };
@@ -94,20 +117,24 @@ export declare const auth: import("better-auth").Auth<{
             }[];
             after: {
                 matcher(context: import("better-auth").HookEndpointContext): true;
-                handler: (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<void>;
+                handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<void>;
             }[];
         };
         options: import("better-auth/plugins").BearerOptions | undefined;
     }, {
         id: "two-factor";
+        version: string;
         endpoints: {
-            enableTwoFactor: import("better-auth").StrictEndpoint<"/two-factor/enable", {
+            enableTwoFactor: import("better-call").StrictEndpoint<"/two-factor/enable", {
                 method: "POST";
-                body: import("better-auth").ZodObject<{
-                    password: import("better-auth").ZodString;
-                    issuer: import("better-auth").ZodOptional<import("better-auth").ZodString>;
-                }, import("better-auth").$strip>;
-                use: ((inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                body: import("zod").ZodObject<{
+                    password: import("zod").ZodOptional<import("zod").ZodString>;
+                    issuer: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip> | import("zod").ZodObject<{
+                    password: import("zod").ZodString;
+                    issuer: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>;
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
                     session: {
                         session: Record<string, any> & {
                             id: string;
@@ -165,12 +192,14 @@ export declare const auth: import("better-auth").Auth<{
                 totpURI: string;
                 backupCodes: string[];
             }>;
-            disableTwoFactor: import("better-auth").StrictEndpoint<"/two-factor/disable", {
+            disableTwoFactor: import("better-call").StrictEndpoint<"/two-factor/disable", {
                 method: "POST";
-                body: import("better-auth").ZodObject<{
-                    password: import("better-auth").ZodString;
-                }, import("better-auth").$strip>;
-                use: ((inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                body: import("zod").ZodObject<{
+                    password: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip> | import("zod").ZodObject<{
+                    password: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
                     session: {
                         session: Record<string, any> & {
                             id: string;
@@ -219,13 +248,13 @@ export declare const auth: import("better-auth").Auth<{
             }, {
                 status: boolean;
             }>;
-            verifyBackupCode: import("better-auth").StrictEndpoint<"/two-factor/verify-backup-code", {
+            verifyBackupCode: import("better-call").StrictEndpoint<"/two-factor/verify-backup-code", {
                 method: "POST";
-                body: import("better-auth").ZodObject<{
-                    code: import("better-auth").ZodString;
-                    disableSession: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
-                    trustDevice: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
-                }, import("better-auth").$strip>;
+                body: import("zod").ZodObject<{
+                    code: import("zod").ZodString;
+                    disableSession: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    trustDevice: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                }, import("zod/v4/core").$strip>;
                 metadata: {
                     openapi: {
                         description: string;
@@ -330,12 +359,14 @@ export declare const auth: import("better-auth").Auth<{
                     image?: string | null | undefined;
                 }) | import("better-auth/plugins").UserWithTwoFactor;
             }>;
-            generateBackupCodes: import("better-auth").StrictEndpoint<"/two-factor/generate-backup-codes", {
+            generateBackupCodes: import("better-call").StrictEndpoint<"/two-factor/generate-backup-codes", {
                 method: "POST";
-                body: import("better-auth").ZodObject<{
-                    password: import("better-auth").ZodString;
-                }, import("better-auth").$strip>;
-                use: ((inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                body: import("zod").ZodObject<{
+                    password: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip> | import("zod").ZodObject<{
+                    password: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
                     session: {
                         session: Record<string, any> & {
                             id: string;
@@ -394,20 +425,20 @@ export declare const auth: import("better-auth").Auth<{
                 status: boolean;
                 backupCodes: string[];
             }>;
-            viewBackupCodes: import("better-auth").StrictEndpoint<string, {
+            viewBackupCodes: import("better-call").StrictEndpoint<string, {
                 method: "POST";
-                body: import("better-auth").ZodObject<{
-                    userId: import("better-auth").ZodCoercedString<unknown>;
-                }, import("better-auth").$strip>;
+                body: import("zod").ZodObject<{
+                    userId: import("zod").ZodCoercedString<unknown>;
+                }, import("zod/v4/core").$strip>;
             }, {
                 status: boolean;
                 backupCodes: string[];
             }>;
-            sendTwoFactorOTP: import("better-auth").StrictEndpoint<"/two-factor/send-otp", {
+            sendTwoFactorOTP: import("better-call").StrictEndpoint<"/two-factor/send-otp", {
                 method: "POST";
-                body: import("better-auth").ZodOptional<import("better-auth").ZodObject<{
-                    trustDevice: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
-                }, import("better-auth").$strip>>;
+                body: import("zod").ZodOptional<import("zod").ZodObject<{
+                    trustDevice: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                }, import("zod/v4/core").$strip>>;
                 metadata: {
                     openapi: {
                         summary: string;
@@ -434,12 +465,12 @@ export declare const auth: import("better-auth").Auth<{
             }, {
                 status: boolean;
             }>;
-            verifyTwoFactorOTP: import("better-auth").StrictEndpoint<"/two-factor/verify-otp", {
+            verifyTwoFactorOTP: import("better-call").StrictEndpoint<"/two-factor/verify-otp", {
                 method: "POST";
-                body: import("better-auth").ZodObject<{
-                    code: import("better-auth").ZodString;
-                    trustDevice: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
-                }, import("better-auth").$strip>;
+                body: import("zod").ZodObject<{
+                    code: import("zod").ZodString;
+                    trustDevice: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                }, import("zod/v4/core").$strip>;
                 metadata: {
                     openapi: {
                         summary: string;
@@ -523,11 +554,11 @@ export declare const auth: import("better-auth").Auth<{
                     image?: string | null | undefined;
                 };
             }>;
-            generateTOTP: import("better-auth").StrictEndpoint<string, {
+            generateTOTP: import("better-call").StrictEndpoint<string, {
                 method: "POST";
-                body: import("better-auth").ZodObject<{
-                    secret: import("better-auth").ZodString;
-                }, import("better-auth").$strip>;
+                body: import("zod").ZodObject<{
+                    secret: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
                 metadata: {
                     openapi: {
                         summary: string;
@@ -554,9 +585,9 @@ export declare const auth: import("better-auth").Auth<{
             }, {
                 code: string;
             }>;
-            getTOTPURI: import("better-auth").StrictEndpoint<"/two-factor/get-totp-uri", {
+            getTOTPURI: import("better-call").StrictEndpoint<"/two-factor/get-totp-uri", {
                 method: "POST";
-                use: ((inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
                     session: {
                         session: Record<string, any> & {
                             id: string;
@@ -579,9 +610,11 @@ export declare const auth: import("better-auth").Auth<{
                         };
                     };
                 }>)[];
-                body: import("better-auth").ZodObject<{
-                    password: import("better-auth").ZodString;
-                }, import("better-auth").$strip>;
+                body: import("zod").ZodObject<{
+                    password: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip> | import("zod").ZodObject<{
+                    password: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
                 metadata: {
                     openapi: {
                         summary: string;
@@ -608,12 +641,12 @@ export declare const auth: import("better-auth").Auth<{
             }, {
                 totpURI: string;
             }>;
-            verifyTOTP: import("better-auth").StrictEndpoint<"/two-factor/verify-totp", {
+            verifyTOTP: import("better-call").StrictEndpoint<"/two-factor/verify-totp", {
                 method: "POST";
-                body: import("better-auth").ZodObject<{
-                    code: import("better-auth").ZodString;
-                    trustDevice: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
-                }, import("better-auth").$strip>;
+                body: import("zod").ZodObject<{
+                    code: import("zod").ZodString;
+                    trustDevice: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                }, import("zod/v4/core").$strip>;
                 metadata: {
                     openapi: {
                         summary: string;
@@ -657,8 +690,9 @@ export declare const auth: import("better-auth").Auth<{
         hooks: {
             after: {
                 matcher(context: import("better-auth").HookEndpointContext): boolean;
-                handler: (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
                     twoFactorRedirect: boolean;
+                    twoFactorMethods: string[];
                 } | undefined>;
             }[];
         };
@@ -696,6 +730,12 @@ export declare const auth: import("better-auth").Auth<{
                         };
                         index: true;
                     };
+                    verified: {
+                        type: "boolean";
+                        required: false;
+                        defaultValue: true;
+                        input: false;
+                    };
                 };
             };
         };
@@ -705,18 +745,19 @@ export declare const auth: import("better-auth").Auth<{
             max: number;
         }[];
         $ERROR_CODES: {
-            readonly OTP_NOT_ENABLED: "OTP not enabled";
-            readonly OTP_HAS_EXPIRED: "OTP has expired";
-            readonly TOTP_NOT_ENABLED: "TOTP not enabled";
-            readonly TWO_FACTOR_NOT_ENABLED: "Two factor isn't enabled";
-            readonly BACKUP_CODES_NOT_ENABLED: "Backup codes aren't enabled";
-            readonly INVALID_BACKUP_CODE: "Invalid backup code";
-            readonly INVALID_CODE: "Invalid code";
-            readonly TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE: "Too many attempts. Please request a new code.";
-            readonly INVALID_TWO_FACTOR_COOKIE: "Invalid two factor cookie";
+            OTP_NOT_ENABLED: import("better-auth").RawError<"OTP_NOT_ENABLED">;
+            OTP_HAS_EXPIRED: import("better-auth").RawError<"OTP_HAS_EXPIRED">;
+            TOTP_NOT_ENABLED: import("better-auth").RawError<"TOTP_NOT_ENABLED">;
+            TWO_FACTOR_NOT_ENABLED: import("better-auth").RawError<"TWO_FACTOR_NOT_ENABLED">;
+            BACKUP_CODES_NOT_ENABLED: import("better-auth").RawError<"BACKUP_CODES_NOT_ENABLED">;
+            INVALID_BACKUP_CODE: import("better-auth").RawError<"INVALID_BACKUP_CODE">;
+            INVALID_CODE: import("better-auth").RawError<"INVALID_CODE">;
+            TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE: import("better-auth").RawError<"TOO_MANY_ATTEMPTS_REQUEST_NEW_CODE">;
+            INVALID_TWO_FACTOR_COOKIE: import("better-auth").RawError<"INVALID_TWO_FACTOR_COOKIE">;
         };
     }, {
         id: "username";
+        version: string;
         init(ctx: import("better-auth").AuthContext): {
             options: {
                 databaseHooks: {
@@ -772,14 +813,14 @@ export declare const auth: import("better-auth").Auth<{
             };
         };
         endpoints: {
-            signInUsername: import("better-auth").StrictEndpoint<"/sign-in/username", {
+            signInUsername: import("better-call").StrictEndpoint<"/sign-in/username", {
                 method: "POST";
-                body: import("better-auth").ZodObject<{
-                    username: import("better-auth").ZodString;
-                    password: import("better-auth").ZodString;
-                    rememberMe: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
-                    callbackURL: import("better-auth").ZodOptional<import("better-auth").ZodString>;
-                }, import("better-auth").$strip>;
+                body: import("zod").ZodObject<{
+                    username: import("zod").ZodString;
+                    password: import("zod").ZodString;
+                    rememberMe: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    callbackURL: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>;
                 metadata: {
                     openapi: {
                         summary: string;
@@ -837,12 +878,12 @@ export declare const auth: import("better-auth").Auth<{
                     username: string;
                     displayUsername: string;
                 };
-            } | null>;
-            isUsernameAvailable: import("better-auth").StrictEndpoint<"/is-username-available", {
+            }>;
+            isUsernameAvailable: import("better-call").StrictEndpoint<"/is-username-available", {
                 method: "POST";
-                body: import("better-auth").ZodObject<{
-                    username: import("better-auth").ZodString;
-                }, import("better-auth").$strip>;
+                body: import("zod").ZodObject<{
+                    username: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
             }, {
                 available: boolean;
             }>;
@@ -857,14 +898,14 @@ export declare const auth: import("better-auth").Auth<{
                         unique: true;
                         returned: true;
                         transform: {
-                            input(value: import("better-auth").DBPrimitive): string | number | boolean | Date | unknown[] | Record<string, unknown> | null | undefined;
+                            input(value: import("better-auth").DBPrimitive): string | number | boolean | Date | Record<string, unknown> | unknown[] | null | undefined;
                         };
                     };
                     displayUsername: {
                         type: "string";
                         required: false;
                         transform: {
-                            input(value: import("better-auth").DBPrimitive): string | number | boolean | Date | unknown[] | Record<string, unknown> | null | undefined;
+                            input(value: import("better-auth").DBPrimitive): string | number | boolean | Date | Record<string, unknown> | unknown[] | null | undefined;
                         };
                     };
                 };
@@ -873,36 +914,37 @@ export declare const auth: import("better-auth").Auth<{
         hooks: {
             before: {
                 matcher(context: import("better-auth").HookEndpointContext): boolean;
-                handler: (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<void>;
+                handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<void>;
             }[];
         };
         options: import("better-auth/plugins").UsernameOptions | undefined;
         $ERROR_CODES: {
-            readonly INVALID_USERNAME_OR_PASSWORD: "Invalid username or password";
-            readonly EMAIL_NOT_VERIFIED: "Email not verified";
-            readonly UNEXPECTED_ERROR: "Unexpected error";
-            readonly USERNAME_IS_ALREADY_TAKEN: "Username is already taken. Please try another.";
-            readonly USERNAME_TOO_SHORT: "Username is too short";
-            readonly USERNAME_TOO_LONG: "Username is too long";
-            readonly INVALID_USERNAME: "Username is invalid";
-            readonly INVALID_DISPLAY_USERNAME: "Display username is invalid";
+            EMAIL_NOT_VERIFIED: import("better-auth").RawError<"EMAIL_NOT_VERIFIED">;
+            UNEXPECTED_ERROR: import("better-auth").RawError<"UNEXPECTED_ERROR">;
+            INVALID_USERNAME_OR_PASSWORD: import("better-auth").RawError<"INVALID_USERNAME_OR_PASSWORD">;
+            USERNAME_IS_ALREADY_TAKEN: import("better-auth").RawError<"USERNAME_IS_ALREADY_TAKEN">;
+            USERNAME_TOO_SHORT: import("better-auth").RawError<"USERNAME_TOO_SHORT">;
+            USERNAME_TOO_LONG: import("better-auth").RawError<"USERNAME_TOO_LONG">;
+            INVALID_USERNAME: import("better-auth").RawError<"INVALID_USERNAME">;
+            INVALID_DISPLAY_USERNAME: import("better-auth").RawError<"INVALID_DISPLAY_USERNAME">;
         };
     }, {
         id: "phone-number";
+        version: string;
         hooks: {
             before: {
                 matcher: (ctx: import("better-auth").HookEndpointContext) => boolean;
-                handler: (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<never>;
+                handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<never>;
             }[];
         };
         endpoints: {
-            signInPhoneNumber: import("better-auth").StrictEndpoint<"/sign-in/phone-number", {
+            signInPhoneNumber: import("better-call").StrictEndpoint<"/sign-in/phone-number", {
                 method: "POST";
-                body: import("better-auth").ZodObject<{
-                    phoneNumber: import("better-auth").ZodString;
-                    password: import("better-auth").ZodString;
-                    rememberMe: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
-                }, import("better-auth").$strip>;
+                body: import("zod").ZodObject<{
+                    phoneNumber: import("zod").ZodString;
+                    password: import("zod").ZodString;
+                    rememberMe: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                }, import("zod/v4/core").$strip>;
                 metadata: {
                     openapi: {
                         summary: string;
@@ -936,11 +978,11 @@ export declare const auth: import("better-auth").Auth<{
                 token: string;
                 user: import("better-auth/plugins").UserWithPhoneNumber;
             }>;
-            sendPhoneNumberOTP: import("better-auth").StrictEndpoint<"/phone-number/send-otp", {
+            sendPhoneNumberOTP: import("better-call").StrictEndpoint<"/phone-number/send-otp", {
                 method: "POST";
-                body: import("better-auth").ZodObject<{
-                    phoneNumber: import("better-auth").ZodString;
-                }, import("better-auth").$strip>;
+                body: import("zod").ZodObject<{
+                    phoneNumber: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
                 metadata: {
                     openapi: {
                         summary: string;
@@ -967,14 +1009,14 @@ export declare const auth: import("better-auth").Auth<{
             }, {
                 message: string;
             }>;
-            verifyPhoneNumber: import("better-auth").StrictEndpoint<"/phone-number/verify", {
+            verifyPhoneNumber: import("better-call").StrictEndpoint<"/phone-number/verify", {
                 method: "POST";
-                body: import("better-auth").ZodObject<{
-                    phoneNumber: import("better-auth").ZodString;
-                    code: import("better-auth").ZodString;
-                    disableSession: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
-                    updatePhoneNumber: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
-                }, import("better-auth").$strip>;
+                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>>;
                 metadata: {
                     openapi: {
                         summary: string;
@@ -1078,11 +1120,11 @@ export declare const auth: import("better-auth").Auth<{
                 token: null;
                 user: import("better-auth/plugins").UserWithPhoneNumber;
             }>;
-            requestPasswordResetPhoneNumber: import("better-auth").StrictEndpoint<"/phone-number/request-password-reset", {
+            requestPasswordResetPhoneNumber: import("better-call").StrictEndpoint<"/phone-number/request-password-reset", {
                 method: "POST";
-                body: import("better-auth").ZodObject<{
-                    phoneNumber: import("better-auth").ZodString;
-                }, import("better-auth").$strip>;
+                body: import("zod").ZodObject<{
+                    phoneNumber: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
                 metadata: {
                     openapi: {
                         description: string;
@@ -1111,13 +1153,13 @@ export declare const auth: import("better-auth").Auth<{
             }, {
                 status: boolean;
             }>;
-            resetPasswordPhoneNumber: import("better-auth").StrictEndpoint<"/phone-number/reset-password", {
+            resetPasswordPhoneNumber: import("better-call").StrictEndpoint<"/phone-number/reset-password", {
                 method: "POST";
-                body: import("better-auth").ZodObject<{
-                    otp: import("better-auth").ZodString;
-                    phoneNumber: import("better-auth").ZodString;
-                    newPassword: import("better-auth").ZodString;
-                }, import("better-auth").$strip>;
+                body: import("zod").ZodObject<{
+                    otp: import("zod").ZodString;
+                    phoneNumber: import("zod").ZodString;
+                    newPassword: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
                 metadata: {
                     openapi: {
                         description: string;
@@ -1173,32 +1215,34 @@ export declare const auth: import("better-auth").Auth<{
         }[];
         options: import("better-auth/plugins").PhoneNumberOptions | undefined;
         $ERROR_CODES: {
-            readonly INVALID_PHONE_NUMBER: "Invalid phone number";
-            readonly PHONE_NUMBER_EXIST: "Phone number already exists";
-            readonly PHONE_NUMBER_NOT_EXIST: "phone number isn't registered";
-            readonly INVALID_PHONE_NUMBER_OR_PASSWORD: "Invalid phone number or password";
-            readonly UNEXPECTED_ERROR: "Unexpected error";
-            readonly OTP_NOT_FOUND: "OTP not found";
-            readonly OTP_EXPIRED: "OTP expired";
-            readonly INVALID_OTP: "Invalid OTP";
-            readonly PHONE_NUMBER_NOT_VERIFIED: "Phone number not verified";
-            readonly PHONE_NUMBER_CANNOT_BE_UPDATED: "Phone number cannot be updated";
-            readonly SEND_OTP_NOT_IMPLEMENTED: "sendOTP not implemented";
-            readonly TOO_MANY_ATTEMPTS: "Too many attempts";
+            OTP_EXPIRED: import("better-auth").RawError<"OTP_EXPIRED">;
+            INVALID_OTP: import("better-auth").RawError<"INVALID_OTP">;
+            TOO_MANY_ATTEMPTS: import("better-auth").RawError<"TOO_MANY_ATTEMPTS">;
+            INVALID_PHONE_NUMBER: import("better-auth").RawError<"INVALID_PHONE_NUMBER">;
+            PHONE_NUMBER_EXIST: import("better-auth").RawError<"PHONE_NUMBER_EXIST">;
+            PHONE_NUMBER_NOT_EXIST: import("better-auth").RawError<"PHONE_NUMBER_NOT_EXIST">;
+            INVALID_PHONE_NUMBER_OR_PASSWORD: import("better-auth").RawError<"INVALID_PHONE_NUMBER_OR_PASSWORD">;
+            UNEXPECTED_ERROR: import("better-auth").RawError<"UNEXPECTED_ERROR">;
+            OTP_NOT_FOUND: import("better-auth").RawError<"OTP_NOT_FOUND">;
+            PHONE_NUMBER_NOT_VERIFIED: import("better-auth").RawError<"PHONE_NUMBER_NOT_VERIFIED">;
+            PHONE_NUMBER_CANNOT_BE_UPDATED: import("better-auth").RawError<"PHONE_NUMBER_CANNOT_BE_UPDATED">;
+            SEND_OTP_NOT_IMPLEMENTED: import("better-auth").RawError<"SEND_OTP_NOT_IMPLEMENTED">;
         };
     }, {
         id: "magic-link";
+        version: string;
         endpoints: {
-            signInMagicLink: import("better-auth").StrictEndpoint<"/sign-in/magic-link", {
+            signInMagicLink: import("better-call").StrictEndpoint<"/sign-in/magic-link", {
                 method: "POST";
                 requireHeaders: true;
-                body: import("better-auth").ZodObject<{
-                    email: import("better-auth").ZodEmail;
-                    name: import("better-auth").ZodOptional<import("better-auth").ZodString>;
-                    callbackURL: import("better-auth").ZodOptional<import("better-auth").ZodString>;
-                    newUserCallbackURL: import("better-auth").ZodOptional<import("better-auth").ZodString>;
-                    errorCallbackURL: import("better-auth").ZodOptional<import("better-auth").ZodString>;
-                }, import("better-auth").$strip>;
+                body: import("zod").ZodObject<{
+                    email: import("zod").ZodEmail;
+                    name: import("zod").ZodOptional<import("zod").ZodString>;
+                    callbackURL: import("zod").ZodOptional<import("zod").ZodString>;
+                    newUserCallbackURL: import("zod").ZodOptional<import("zod").ZodString>;
+                    errorCallbackURL: import("zod").ZodOptional<import("zod").ZodString>;
+                    metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
+                }, import("zod/v4/core").$strip>;
                 metadata: {
                     openapi: {
                         operationId: string;
@@ -1225,15 +1269,15 @@ export declare const auth: import("better-auth").Auth<{
             }, {
                 status: boolean;
             }>;
-            magicLinkVerify: import("better-auth").StrictEndpoint<"/magic-link/verify", {
+            magicLinkVerify: import("better-call").StrictEndpoint<"/magic-link/verify", {
                 method: "GET";
-                query: import("better-auth").ZodObject<{
-                    token: import("better-auth").ZodString;
-                    callbackURL: import("better-auth").ZodOptional<import("better-auth").ZodString>;
-                    errorCallbackURL: import("better-auth").ZodOptional<import("better-auth").ZodString>;
-                    newUserCallbackURL: import("better-auth").ZodOptional<import("better-auth").ZodString>;
-                }, import("better-auth").$strip>;
-                use: ((inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<void>)[];
+                query: import("zod").ZodObject<{
+                    token: import("zod").ZodString;
+                    callbackURL: import("zod").ZodOptional<import("zod").ZodString>;
+                    errorCallbackURL: import("zod").ZodOptional<import("zod").ZodString>;
+                    newUserCallbackURL: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>;
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<void>)[];
                 requireHeaders: true;
                 metadata: {
                     openapi: {
@@ -1272,6 +1316,16 @@ export declare const auth: import("better-auth").Auth<{
                     name: string;
                     image?: string | null | undefined;
                 };
+                session: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    userId: string;
+                    expiresAt: Date;
+                    token: string;
+                    ipAddress?: string | null | undefined;
+                    userAgent?: string | null | undefined;
+                };
             }>;
         };
         rateLimit: {
@@ -1282,6 +1336,7 @@ export declare const auth: import("better-auth").Auth<{
         options: import("better-auth/plugins").MagicLinkOptions;
     }, {
         id: "email-otp";
+        version: string;
         init(ctx: import("better-auth").AuthContext): {
             options: {
                 emailVerification: {
@@ -1294,16 +1349,17 @@ export declare const auth: import("better-auth").Auth<{
             };
         } | undefined;
         endpoints: {
-            sendVerificationOTP: import("better-auth").StrictEndpoint<"/email-otp/send-verification-otp", {
+            sendVerificationOTP: import("better-call").StrictEndpoint<"/email-otp/send-verification-otp", {
                 method: "POST";
-                body: import("better-auth").ZodObject<{
-                    email: import("better-auth").ZodString;
-                    type: import("better-auth").ZodEnum<{
+                body: import("zod").ZodObject<{
+                    email: import("zod").ZodString;
+                    type: import("zod").ZodEnum<{
                         "sign-in": "sign-in";
+                        "change-email": "change-email";
                         "email-verification": "email-verification";
                         "forget-password": "forget-password";
                     }>;
-                }, import("better-auth").$strip>;
+                }, import("zod/v4/core").$strip>;
                 metadata: {
                     openapi: {
                         operationId: string;
@@ -1330,16 +1386,17 @@ export declare const auth: import("better-auth").Auth<{
             }, {
                 success: boolean;
             }>;
-            createVerificationOTP: import("better-auth").StrictEndpoint<string, {
+            createVerificationOTP: import("better-call").StrictEndpoint<string, {
                 method: "POST";
-                body: import("better-auth").ZodObject<{
-                    email: import("better-auth").ZodString;
-                    type: import("better-auth").ZodEnum<{
+                body: import("zod").ZodObject<{
+                    email: import("zod").ZodString;
+                    type: import("zod").ZodEnum<{
                         "sign-in": "sign-in";
+                        "change-email": "change-email";
                         "email-verification": "email-verification";
                         "forget-password": "forget-password";
                     }>;
-                }, import("better-auth").$strip>;
+                }, import("zod/v4/core").$strip>;
                 metadata: {
                     openapi: {
                         operationId: string;
@@ -1359,16 +1416,17 @@ export declare const auth: import("better-auth").Auth<{
                     };
                 };
             }, string>;
-            getVerificationOTP: import("better-auth").StrictEndpoint<string, {
+            getVerificationOTP: import("better-call").StrictEndpoint<string, {
                 method: "GET";
-                query: import("better-auth").ZodObject<{
-                    email: import("better-auth").ZodString;
-                    type: import("better-auth").ZodEnum<{
+                query: import("zod").ZodObject<{
+                    email: import("zod").ZodString;
+                    type: import("zod").ZodEnum<{
                         "sign-in": "sign-in";
+                        "change-email": "change-email";
                         "email-verification": "email-verification";
                         "forget-password": "forget-password";
                     }>;
-                }, import("better-auth").$strip>;
+                }, import("zod/v4/core").$strip>;
                 metadata: {
                     openapi: {
                         operationId: string;
@@ -1400,17 +1458,18 @@ export declare const auth: import("better-auth").Auth<{
             } | {
                 otp: string;
             }>;
-            checkVerificationOTP: import("better-auth").StrictEndpoint<"/email-otp/check-verification-otp", {
+            checkVerificationOTP: import("better-call").StrictEndpoint<"/email-otp/check-verification-otp", {
                 method: "POST";
-                body: import("better-auth").ZodObject<{
-                    email: import("better-auth").ZodString;
-                    type: import("better-auth").ZodEnum<{
+                body: import("zod").ZodObject<{
+                    email: import("zod").ZodString;
+                    type: import("zod").ZodEnum<{
                         "sign-in": "sign-in";
+                        "change-email": "change-email";
                         "email-verification": "email-verification";
                         "forget-password": "forget-password";
                     }>;
-                    otp: import("better-auth").ZodString;
-                }, import("better-auth").$strip>;
+                    otp: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
                 metadata: {
                     openapi: {
                         operationId: string;
@@ -1437,12 +1496,12 @@ export declare const auth: import("better-auth").Auth<{
             }, {
                 success: boolean;
             }>;
-            verifyEmailOTP: import("better-auth").StrictEndpoint<"/email-otp/verify-email", {
+            verifyEmailOTP: import("better-call").StrictEndpoint<"/email-otp/verify-email", {
                 method: "POST";
-                body: import("better-auth").ZodObject<{
-                    email: import("better-auth").ZodString;
-                    otp: import("better-auth").ZodString;
-                }, import("better-auth").$strip>;
+                body: import("zod").ZodObject<{
+                    email: import("zod").ZodString;
+                    otp: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
                 metadata: {
                     openapi: {
                         description: string;
@@ -1501,12 +1560,14 @@ export declare const auth: import("better-auth").Auth<{
                     image?: string | null | undefined;
                 } & Record<string, any>;
             }>;
-            signInEmailOTP: import("better-auth").StrictEndpoint<"/sign-in/email-otp", {
+            signInEmailOTP: import("better-call").StrictEndpoint<"/sign-in/email-otp", {
                 method: "POST";
-                body: import("better-auth").ZodObject<{
-                    email: import("better-auth").ZodString;
-                    otp: import("better-auth").ZodString;
-                }, import("better-auth").$strip>;
+                body: import("zod").ZodIntersection<import("zod").ZodObject<{
+                    email: import("zod").ZodString;
+                    otp: import("zod").ZodString;
+                    name: import("zod").ZodOptional<import("zod").ZodString>;
+                    image: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>, import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
                 metadata: {
                     openapi: {
                         operationId: string;
@@ -1547,11 +1608,11 @@ export declare const auth: import("better-auth").Auth<{
                     image?: string | null | undefined;
                 };
             }>;
-            forgetPasswordEmailOTP: import("better-auth").StrictEndpoint<"/forget-password/email-otp", {
+            requestPasswordResetEmailOTP: import("better-call").StrictEndpoint<"/email-otp/request-password-reset", {
                 method: "POST";
-                body: import("better-auth").ZodObject<{
-                    email: import("better-auth").ZodString;
-                }, import("better-auth").$strip>;
+                body: import("zod").ZodObject<{
+                    email: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
                 metadata: {
                     openapi: {
                         operationId: string;
@@ -1579,13 +1640,155 @@ export declare const auth: import("better-auth").Auth<{
             }, {
                 success: boolean;
             }>;
-            resetPasswordEmailOTP: import("better-auth").StrictEndpoint<"/email-otp/reset-password", {
+            forgetPasswordEmailOTP: import("better-call").StrictEndpoint<"/forget-password/email-otp", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    email: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                success: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                success: boolean;
+            }>;
+            resetPasswordEmailOTP: import("better-call").StrictEndpoint<"/email-otp/reset-password", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    email: import("zod").ZodString;
+                    otp: import("zod").ZodString;
+                    password: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                success: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                success: boolean;
+            }>;
+            requestEmailChangeEmailOTP: import("better-call").StrictEndpoint<"/email-otp/request-email-change", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    newEmail: import("zod").ZodString;
+                    otp: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>;
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                    session: {
+                        session: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                }>)[];
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                success: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                success: boolean;
+            }>;
+            changeEmailEmailOTP: import("better-call").StrictEndpoint<"/email-otp/change-email", {
                 method: "POST";
-                body: import("better-auth").ZodObject<{
-                    email: import("better-auth").ZodString;
-                    otp: import("better-auth").ZodString;
-                    password: import("better-auth").ZodString;
-                }, import("better-auth").$strip>;
+                body: import("zod").ZodObject<{
+                    newEmail: import("zod").ZodString;
+                    otp: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").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;
@@ -1593,10 +1796,10 @@ export declare const auth: import("better-auth").Auth<{
                         responses: {
                             200: {
                                 description: string;
-                                contnt: {
+                                content: {
                                     "application/json": {
                                         schema: {
-                                            type: string;
+                                            type: "object";
                                             properties: {
                                                 success: {
                                                     type: string;
@@ -1616,14 +1819,9 @@ export declare const auth: import("better-auth").Auth<{
         hooks: {
             after: {
                 matcher(context: import("better-auth").HookEndpointContext): boolean;
-                handler: (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<void>;
+                handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<void>;
             }[];
         };
-        $ERROR_CODES: {
-            readonly OTP_EXPIRED: "OTP expired";
-            readonly INVALID_OTP: "Invalid OTP";
-            readonly TOO_MANY_ATTEMPTS: "Too many attempts";
-        };
         rateLimit: ({
             pathMatcher(path: string): path is "/email-otp/send-verification-otp";
             window: number;
@@ -1640,10 +1838,36 @@ export declare const auth: import("better-auth").Auth<{
             pathMatcher(path: string): path is "/sign-in/email-otp";
             window: number;
             max: number;
+        } | {
+            pathMatcher(path: string): path is "/email-otp/request-password-reset";
+            window: number;
+            max: number;
+        } | {
+            pathMatcher(path: string): path is "/email-otp/reset-password";
+            window: number;
+            max: number;
+        } | {
+            pathMatcher(path: string): path is "/forget-password/email-otp";
+            window: number;
+            max: number;
+        } | {
+            pathMatcher(path: string): path is "/email-otp/request-email-change";
+            window: number;
+            max: number;
+        } | {
+            pathMatcher(path: string): path is "/email-otp/change-email";
+            window: number;
+            max: number;
         })[];
         options: import("better-auth/plugins").EmailOTPOptions;
+        $ERROR_CODES: {
+            OTP_EXPIRED: import("better-auth").RawError<"OTP_EXPIRED">;
+            INVALID_OTP: import("better-auth").RawError<"INVALID_OTP">;
+            TOO_MANY_ATTEMPTS: import("better-auth").RawError<"TOO_MANY_ATTEMPTS">;
+        };
     }, {
         id: "admin";
+        version: string;
         init(): {
             options: {
                 databaseHooks: {
@@ -1691,21 +1915,30 @@ export declare const auth: import("better-auth").Auth<{
         hooks: {
             after: {
                 matcher(context: import("better-auth").HookEndpointContext): boolean;
-                handler: (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<import("better-auth/plugins").SessionWithImpersonatedBy[] | undefined>;
+                handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<import("better-auth/plugins").SessionWithImpersonatedBy[] | undefined>;
             }[];
         };
         endpoints: {
-            setRole: import("better-auth").StrictEndpoint<"/admin/set-role", {
+            setRole: import("better-call").StrictEndpoint<"/admin/set-role", {
                 method: "POST";
-                body: import("better-auth").ZodObject<{
-                    userId: import("better-auth").ZodCoercedString<unknown>;
-                    role: import("better-auth").ZodUnion<readonly [import("better-auth").ZodString, import("better-auth").ZodArray<import("better-auth").ZodString>]>;
-                }, import("better-auth").$strip>;
+                body: import("zod").ZodObject<{
+                    userId: import("zod").ZodCoercedString<unknown>;
+                    role: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>]>;
+                }, import("zod/v4/core").$strip>;
                 requireHeaders: true;
-                use: ((inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
                     session: {
                         user: import("better-auth/plugins").UserWithRole;
-                        session: import("better-auth").Session;
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
                     };
                 }>)[];
                 metadata: {
@@ -1741,15 +1974,24 @@ export declare const auth: import("better-auth").Auth<{
             }, {
                 user: import("better-auth/plugins").UserWithRole;
             }>;
-            getUser: import("better-auth").StrictEndpoint<"/admin/get-user", {
+            getUser: import("better-call").StrictEndpoint<"/admin/get-user", {
                 method: "GET";
-                query: import("better-auth").ZodObject<{
-                    id: import("better-auth").ZodString;
-                }, import("better-auth").$strip>;
-                use: ((inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                query: import("zod").ZodObject<{
+                    id: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
                     session: {
                         user: import("better-auth/plugins").UserWithRole;
-                        session: import("better-auth").Session;
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
                     };
                 }>)[];
                 metadata: {
@@ -1777,15 +2019,15 @@ export declare const auth: import("better-auth").Auth<{
                     };
                 };
             }, import("better-auth/plugins").UserWithRole>;
-            createUser: import("better-auth").StrictEndpoint<"/admin/create-user", {
+            createUser: import("better-call").StrictEndpoint<"/admin/create-user", {
                 method: "POST";
-                body: import("better-auth").ZodObject<{
-                    email: import("better-auth").ZodString;
-                    password: import("better-auth").ZodOptional<import("better-auth").ZodString>;
-                    name: import("better-auth").ZodString;
-                    role: import("better-auth").ZodOptional<import("better-auth").ZodUnion<readonly [import("better-auth").ZodString, import("better-auth").ZodArray<import("better-auth").ZodString>]>>;
-                    data: import("better-auth").ZodOptional<import("better-auth").ZodRecord<import("better-auth").ZodString, import("better-auth").ZodAny>>;
-                }, import("better-auth").$strip>;
+                body: import("zod").ZodObject<{
+                    email: import("zod").ZodString;
+                    password: import("zod").ZodOptional<import("zod").ZodString>;
+                    name: import("zod").ZodString;
+                    role: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>]>>;
+                    data: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
+                }, import("zod/v4/core").$strip>;
                 metadata: {
                     openapi: {
                         operationId: string;
@@ -1822,16 +2064,25 @@ export declare const auth: import("better-auth").Auth<{
             }, {
                 user: import("better-auth/plugins").UserWithRole;
             }>;
-            adminUpdateUser: import("better-auth").StrictEndpoint<"/admin/update-user", {
+            adminUpdateUser: import("better-call").StrictEndpoint<"/admin/update-user", {
                 method: "POST";
-                body: import("better-auth").ZodObject<{
-                    userId: import("better-auth").ZodCoercedString<unknown>;
-                    data: import("better-auth").ZodRecord<import("better-auth").ZodAny, import("better-auth").ZodAny>;
-                }, import("better-auth").$strip>;
-                use: ((inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                body: import("zod").ZodObject<{
+                    userId: import("zod").ZodCoercedString<unknown>;
+                    data: import("zod").ZodRecord<import("zod").ZodAny, import("zod").ZodAny>;
+                }, import("zod/v4/core").$strip>;
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
                     session: {
                         user: import("better-auth/plugins").UserWithRole;
-                        session: import("better-auth").Session;
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
                     };
                 }>)[];
                 metadata: {
@@ -1859,44 +2110,57 @@ export declare const auth: import("better-auth").Auth<{
                     };
                 };
             }, import("better-auth/plugins").UserWithRole>;
-            listUsers: import("better-auth").StrictEndpoint<"/admin/list-users", {
+            listUsers: import("better-call").StrictEndpoint<"/admin/list-users", {
                 method: "GET";
-                use: ((inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
                     session: {
                         user: import("better-auth/plugins").UserWithRole;
-                        session: import("better-auth").Session;
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
                     };
                 }>)[];
-                query: import("better-auth").ZodObject<{
-                    searchValue: import("better-auth").ZodOptional<import("better-auth").ZodString>;
-                    searchField: import("better-auth").ZodOptional<import("better-auth").ZodEnum<{
-                        name: "name";
+                query: import("zod").ZodObject<{
+                    searchValue: import("zod").ZodOptional<import("zod").ZodString>;
+                    searchField: import("zod").ZodOptional<import("zod").ZodEnum<{
                         email: "email";
+                        name: "name";
                     }>>;
-                    searchOperator: import("better-auth").ZodOptional<import("better-auth").ZodEnum<{
+                    searchOperator: import("zod").ZodOptional<import("zod").ZodEnum<{
                         contains: "contains";
                         starts_with: "starts_with";
                         ends_with: "ends_with";
                     }>>;
-                    limit: import("better-auth").ZodOptional<import("better-auth").ZodUnion<[import("better-auth").ZodString, import("better-auth").ZodNumber]>>;
-                    offset: import("better-auth").ZodOptional<import("better-auth").ZodUnion<[import("better-auth").ZodString, import("better-auth").ZodNumber]>>;
-                    sortBy: import("better-auth").ZodOptional<import("better-auth").ZodString>;
-                    sortDirection: import("better-auth").ZodOptional<import("better-auth").ZodEnum<{
+                    limit: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>>;
+                    offset: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>>;
+                    sortBy: import("zod").ZodOptional<import("zod").ZodString>;
+                    sortDirection: import("zod").ZodOptional<import("zod").ZodEnum<{
                         asc: "asc";
                         desc: "desc";
                     }>>;
-                    filterField: import("better-auth").ZodOptional<import("better-auth").ZodString>;
-                    filterValue: import("better-auth").ZodOptional<import("better-auth").ZodUnion<[import("better-auth").ZodUnion<[import("better-auth").ZodString, import("better-auth").ZodNumber]>, import("better-auth").ZodBoolean]>>;
-                    filterOperator: import("better-auth").ZodOptional<import("better-auth").ZodEnum<{
+                    filterField: import("zod").ZodOptional<import("zod").ZodString>;
+                    filterValue: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodUnion<[import("zod").ZodUnion<[import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>, import("zod").ZodBoolean]>, import("zod").ZodArray<import("zod").ZodString>]>, import("zod").ZodArray<import("zod").ZodNumber>]>>;
+                    filterOperator: import("zod").ZodOptional<import("zod").ZodEnum<{
                         eq: "eq";
                         ne: "ne";
-                        lt: "lt";
-                        lte: "lte";
                         gt: "gt";
                         gte: "gte";
+                        lt: "lt";
+                        lte: "lte";
+                        in: "in";
+                        not_in: "not_in";
                         contains: "contains";
+                        starts_with: "starts_with";
+                        ends_with: "ends_with";
                     }>>;
-                }, import("better-auth").$strip>;
+                }, import("zod/v4/core").$strip>;
                 metadata: {
                     openapi: {
                         operationId: string;
@@ -1937,23 +2201,27 @@ export declare const auth: import("better-auth").Auth<{
             }, {
                 users: import("better-auth/plugins").UserWithRole[];
                 total: number;
-                limit: number | undefined;
-                offset: number | undefined;
-            } | {
-                users: never[];
-                total: number;
             }>;
-            listUserSessions: import("better-auth").StrictEndpoint<"/admin/list-user-sessions", {
+            listUserSessions: import("better-call").StrictEndpoint<"/admin/list-user-sessions", {
                 method: "POST";
-                use: ((inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
                     session: {
                         user: import("better-auth/plugins").UserWithRole;
-                        session: import("better-auth").Session;
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
                     };
                 }>)[];
-                body: import("better-auth").ZodObject<{
-                    userId: import("better-auth").ZodCoercedString<unknown>;
-                }, import("better-auth").$strip>;
+                body: import("zod").ZodObject<{
+                    userId: import("zod").ZodCoercedString<unknown>;
+                }, import("zod/v4/core").$strip>;
                 metadata: {
                     openapi: {
                         operationId: string;
@@ -1984,15 +2252,24 @@ export declare const auth: import("better-auth").Auth<{
             }, {
                 sessions: import("better-auth/plugins").SessionWithImpersonatedBy[];
             }>;
-            unbanUser: import("better-auth").StrictEndpoint<"/admin/unban-user", {
+            unbanUser: import("better-call").StrictEndpoint<"/admin/unban-user", {
                 method: "POST";
-                body: import("better-auth").ZodObject<{
-                    userId: import("better-auth").ZodCoercedString<unknown>;
-                }, import("better-auth").$strip>;
-                use: ((inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                body: import("zod").ZodObject<{
+                    userId: import("zod").ZodCoercedString<unknown>;
+                }, import("zod/v4/core").$strip>;
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
                     session: {
                         user: import("better-auth/plugins").UserWithRole;
-                        session: import("better-auth").Session;
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
                     };
                 }>)[];
                 metadata: {
@@ -2022,17 +2299,26 @@ export declare const auth: import("better-auth").Auth<{
             }, {
                 user: import("better-auth/plugins").UserWithRole;
             }>;
-            banUser: import("better-auth").StrictEndpoint<"/admin/ban-user", {
+            banUser: import("better-call").StrictEndpoint<"/admin/ban-user", {
                 method: "POST";
-                body: import("better-auth").ZodObject<{
-                    userId: import("better-auth").ZodCoercedString<unknown>;
-                    banReason: import("better-auth").ZodOptional<import("better-auth").ZodString>;
-                    banExpiresIn: import("better-auth").ZodOptional<import("better-auth").ZodNumber>;
-                }, import("better-auth").$strip>;
-                use: ((inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                body: import("zod").ZodObject<{
+                    userId: import("zod").ZodCoercedString<unknown>;
+                    banReason: import("zod").ZodOptional<import("zod").ZodString>;
+                    banExpiresIn: import("zod").ZodOptional<import("zod").ZodNumber>;
+                }, import("zod/v4/core").$strip>;
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
                     session: {
                         user: import("better-auth/plugins").UserWithRole;
-                        session: import("better-auth").Session;
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
                     };
                 }>)[];
                 metadata: {
@@ -2062,15 +2348,24 @@ export declare const auth: import("better-auth").Auth<{
             }, {
                 user: import("better-auth/plugins").UserWithRole;
             }>;
-            impersonateUser: import("better-auth").StrictEndpoint<"/admin/impersonate-user", {
+            impersonateUser: import("better-call").StrictEndpoint<"/admin/impersonate-user", {
                 method: "POST";
-                body: import("better-auth").ZodObject<{
-                    userId: import("better-auth").ZodCoercedString<unknown>;
-                }, import("better-auth").$strip>;
-                use: ((inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                body: import("zod").ZodObject<{
+                    userId: import("zod").ZodCoercedString<unknown>;
+                }, import("zod/v4/core").$strip>;
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
                     session: {
                         user: import("better-auth/plugins").UserWithRole;
-                        session: import("better-auth").Session;
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
                     };
                 }>)[];
                 metadata: {
@@ -2113,7 +2408,7 @@ export declare const auth: import("better-auth").Auth<{
                 };
                 user: import("better-auth/plugins").UserWithRole;
             }>;
-            stopImpersonating: import("better-auth").StrictEndpoint<"/admin/stop-impersonating", {
+            stopImpersonating: import("better-call").StrictEndpoint<"/admin/stop-impersonating", {
                 method: "POST";
                 requireHeaders: true;
             }, {
@@ -2137,15 +2432,24 @@ export declare const auth: import("better-auth").Auth<{
                     image?: string | null | undefined;
                 } & Record<string, any>;
             }>;
-            revokeUserSession: import("better-auth").StrictEndpoint<"/admin/revoke-user-session", {
+            revokeUserSession: import("better-call").StrictEndpoint<"/admin/revoke-user-session", {
                 method: "POST";
-                body: import("better-auth").ZodObject<{
-                    sessionToken: import("better-auth").ZodString;
-                }, import("better-auth").$strip>;
-                use: ((inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                body: import("zod").ZodObject<{
+                    sessionToken: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
                     session: {
                         user: import("better-auth/plugins").UserWithRole;
-                        session: import("better-auth").Session;
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
                     };
                 }>)[];
                 metadata: {
@@ -2175,15 +2479,24 @@ export declare const auth: import("better-auth").Auth<{
             }, {
                 success: boolean;
             }>;
-            revokeUserSessions: import("better-auth").StrictEndpoint<"/admin/revoke-user-sessions", {
+            revokeUserSessions: import("better-call").StrictEndpoint<"/admin/revoke-user-sessions", {
                 method: "POST";
-                body: import("better-auth").ZodObject<{
-                    userId: import("better-auth").ZodCoercedString<unknown>;
-                }, import("better-auth").$strip>;
-                use: ((inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                body: import("zod").ZodObject<{
+                    userId: import("zod").ZodCoercedString<unknown>;
+                }, import("zod/v4/core").$strip>;
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
                     session: {
                         user: import("better-auth/plugins").UserWithRole;
-                        session: import("better-auth").Session;
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
                     };
                 }>)[];
                 metadata: {
@@ -2213,15 +2526,24 @@ export declare const auth: import("better-auth").Auth<{
             }, {
                 success: boolean;
             }>;
-            removeUser: import("better-auth").StrictEndpoint<"/admin/remove-user", {
+            removeUser: import("better-call").StrictEndpoint<"/admin/remove-user", {
                 method: "POST";
-                body: import("better-auth").ZodObject<{
-                    userId: import("better-auth").ZodCoercedString<unknown>;
-                }, import("better-auth").$strip>;
-                use: ((inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                body: import("zod").ZodObject<{
+                    userId: import("zod").ZodCoercedString<unknown>;
+                }, import("zod/v4/core").$strip>;
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
                     session: {
                         user: import("better-auth/plugins").UserWithRole;
-                        session: import("better-auth").Session;
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
                     };
                 }>)[];
                 metadata: {
@@ -2251,16 +2573,25 @@ export declare const auth: import("better-auth").Auth<{
             }, {
                 success: boolean;
             }>;
-            setUserPassword: import("better-auth").StrictEndpoint<"/admin/set-user-password", {
+            setUserPassword: import("better-call").StrictEndpoint<"/admin/set-user-password", {
                 method: "POST";
-                body: import("better-auth").ZodObject<{
-                    newPassword: import("better-auth").ZodString;
-                    userId: import("better-auth").ZodCoercedString<unknown>;
-                }, import("better-auth").$strip>;
-                use: ((inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                body: import("zod").ZodObject<{
+                    newPassword: import("zod").ZodString;
+                    userId: import("zod").ZodCoercedString<unknown>;
+                }, import("zod/v4/core").$strip>;
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
                     session: {
                         user: import("better-auth/plugins").UserWithRole;
-                        session: import("better-auth").Session;
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
                     };
                 }>)[];
                 metadata: {
@@ -2290,18 +2621,16 @@ export declare const auth: import("better-auth").Auth<{
             }, {
                 status: boolean;
             }>;
-            userHasPermission: import("better-auth").StrictEndpoint<"/admin/has-permission", {
+            userHasPermission: import("better-call").StrictEndpoint<"/admin/has-permission", {
                 method: "POST";
-                body: import("better-auth").ZodIntersection<import("better-auth").ZodObject<{
-                    userId: import("better-auth").ZodOptional<import("better-auth").ZodCoercedString<unknown>>;
-                    role: import("better-auth").ZodOptional<import("better-auth").ZodString>;
-                }, import("better-auth").$strip>, import("better-auth").ZodUnion<readonly [import("better-auth").ZodObject<{
-                    permission: import("better-auth").ZodRecord<import("better-auth").ZodString, import("better-auth").ZodArray<import("better-auth").ZodString>>;
-                    permissions: import("better-auth").ZodUndefined;
-                }, import("better-auth").$strip>, import("better-auth").ZodObject<{
-                    permission: import("better-auth").ZodUndefined;
-                    permissions: import("better-auth").ZodRecord<import("better-auth").ZodString, import("better-auth").ZodArray<import("better-auth").ZodString>>;
-                }, import("better-auth").$strip>]>>;
+                body: import("zod").ZodIntersection<import("zod").ZodObject<{
+                    userId: import("zod").ZodOptional<import("zod").ZodCoercedString<unknown>>;
+                    role: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>, import("zod").ZodXor<readonly [import("zod").ZodObject<{
+                    permission: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>>;
+                }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                    permissions: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>>;
+                }, import("zod/v4/core").$strip>]>>;
                 metadata: {
                     openapi: {
                         description: string;
@@ -2311,11 +2640,6 @@ export declare const auth: import("better-auth").Auth<{
                                     schema: {
                                         type: "object";
                                         properties: {
-                                            permission: {
-                                                type: string;
-                                                description: string;
-                                                deprecated: boolean;
-                                            };
                                             permissions: {
                                                 type: string;
                                                 description: string;
@@ -2349,55 +2673,7 @@ export declare const auth: import("better-auth").Auth<{
                         };
                     };
                     $Infer: {
-                        body: ({
-                            permission: {
-                                readonly "welfare_cycle:plan"?: ("read" | "list" | "create" | "update" | "delete")[] | undefined;
-                                readonly "welfare_cycle:subscription"?: ("read" | "list" | "create")[] | undefined;
-                                readonly "welfare_cycle:payout"?: ("read" | "list" | "create")[] | undefined;
-                                readonly "ledger_account:import"?: ("read" | "list" | "create")[] | undefined;
-                                readonly "wallet:container"?: ("read" | "list")[] | undefined;
-                                readonly "wallet:type"?: ("read" | "list" | "create" | "update" | "delete")[] | undefined;
-                                readonly "news:news"?: ("read" | "list" | "create" | "update" | "delete")[] | undefined;
-                                readonly "news:category"?: ("read" | "list" | "create" | "update" | "delete")[] | undefined;
-                                readonly "trade_market:market"?: ("read" | "list" | "create" | "update" | "delete")[] | undefined;
-                                readonly "trade_market:order"?: ("read" | "list" | "create")[] | undefined;
-                                readonly "transfer:order"?: ("read" | "list" | "create")[] | undefined;
-                                readonly "team:member"?: ("read" | "list" | "stats")[] | undefined;
-                                readonly "referral:depth-config"?: ("read" | "list" | "create" | "update" | "delete")[] | undefined;
-                                readonly "referral:relation"?: ("read" | "list" | "bind")[] | undefined;
-                                readonly "shipping_address:item"?: ("read" | "list" | "create" | "update" | "delete")[] | undefined;
-                                readonly "receipt_method:item"?: ("read" | "list" | "create" | "update" | "delete")[] | undefined;
-                                readonly "notification:notification"?: ("read" | "list" | "update")[] | undefined;
-                                readonly "notification:admin"?: ("read" | "list" | "create" | "stats")[] | undefined;
-                                readonly "withdraw:manage"?: ("read" | "create")[] | undefined;
-                                readonly "withdraw:review"?: ("read" | "approve" | "reject" | "paid")[] | undefined;
-                                readonly "market_data:ticker"?: ("read" | "latest")[] | undefined;
-                                readonly "market_data:kline"?: ("read" | "list")[] | undefined;
-                                readonly "market_data:admin"?: ("read" | "list" | "run")[] | undefined;
-                                readonly "market_pricing:strategy"?: ("read" | "list" | "create" | "update" | "delete" | "run")[] | undefined;
-                                readonly "ledger:entry"?: ("read" | "list" | "view_all" | "adjust")[] | undefined;
-                                readonly "ledger-account:type"?: ("read" | "list" | "create" | "update")[] | undefined;
-                                readonly "ledger-account:account"?: ("read" | "list" | "update")[] | undefined;
-                                readonly "deposit:order"?: ("read" | "list" | "create" | "update")[] | undefined;
-                                readonly "deposit:review"?: ("read" | "list" | "update")[] | undefined;
-                                readonly "checkIn:checkIn"?: ("read" | "list" | "create")[] | undefined;
-                                readonly "checkIn:admin"?: ("read" | "list")[] | undefined;
-                                readonly "kyc:method"?: ("read" | "create" | "update")[] | undefined;
-                                readonly "kyc:admin"?: ("read" | "list" | "approve" | "reject")[] | undefined;
-                                readonly "user:profile"?: ("read" | "update")[] | undefined;
-                                readonly "user:referral"?: "bind"[] | undefined;
-                                readonly "admin:user-profile"?: ("read" | "list" | "update")[] | undefined;
-                                readonly "asset_price:price"?: ("read" | "list" | "latest")[] | undefined;
-                                readonly "asset_price:admin"?: ("read" | "list" | "create" | "latest")[] | undefined;
-                                readonly "asset-type:type"?: ("read" | "list" | "update")[] | undefined;
-                                readonly "asset_convert_product:product"?: ("read" | "list" | "create" | "update" | "delete")[] | undefined;
-                                readonly "asset_convert_product:order"?: ("read" | "list" | "create")[] | undefined;
-                                readonly "asset:item"?: ("read" | "list" | "create" | "update")[] | undefined;
-                                readonly user?: ("list" | "create" | "update" | "delete" | "set-role" | "ban" | "impersonate" | "set-password" | "get")[] | undefined;
-                                readonly session?: ("list" | "delete" | "revoke")[] | undefined;
-                            };
-                            permissions?: never | undefined;
-                        } | {
+                        body: {
                             permissions: {
                                 readonly "welfare_cycle:plan"?: ("read" | "list" | "create" | "update" | "delete")[] | undefined;
                                 readonly "welfare_cycle:subscription"?: ("read" | "list" | "create")[] | undefined;
@@ -2422,7 +2698,7 @@ export declare const auth: import("better-auth").Auth<{
                                 readonly "market_data:ticker"?: ("read" | "latest")[] | undefined;
                                 readonly "market_data:kline"?: ("read" | "list")[] | undefined;
                                 readonly "market_data:admin"?: ("read" | "list" | "run")[] | undefined;
-                                readonly "market_pricing:strategy"?: ("read" | "list" | "create" | "update" | "delete" | "run")[] | undefined;
+                                readonly "market_pricing:strategy"?: ("read" | "list" | "create" | "update" | "run" | "delete")[] | undefined;
                                 readonly "ledger:entry"?: ("read" | "list" | "view_all" | "adjust")[] | undefined;
                                 readonly "ledger-account:type"?: ("read" | "list" | "create" | "update")[] | undefined;
                                 readonly "ledger-account:account"?: ("read" | "list" | "update")[] | undefined;
@@ -2437,15 +2713,14 @@ export declare const auth: import("better-auth").Auth<{
                                 readonly "admin:user-profile"?: ("read" | "list" | "update")[] | undefined;
                                 readonly "asset_price:price"?: ("read" | "list" | "latest")[] | undefined;
                                 readonly "asset_price:admin"?: ("read" | "list" | "create" | "latest")[] | undefined;
-                                readonly "asset-type:type"?: ("read" | "list" | "update")[] | undefined;
-                                readonly "asset_convert_product:product"?: ("read" | "list" | "create" | "update" | "delete")[] | undefined;
-                                readonly "asset_convert_product:order"?: ("read" | "list" | "create")[] | undefined;
+                                readonly "asset-type:type"?: ("read" | "list" | "create" | "update")[] | undefined;
+                                readonly "asset_convert_product:product"?: ("read" | "list" | "create" | "update")[] | undefined;
+                                readonly "asset_convert_product:order"?: ("read" | "list")[] | undefined;
                                 readonly "asset:item"?: ("read" | "list" | "create" | "update")[] | undefined;
-                                readonly user?: ("list" | "create" | "update" | "delete" | "set-role" | "ban" | "impersonate" | "set-password" | "get")[] | undefined;
+                                readonly user?: ("list" | "create" | "update" | "delete" | "set-role" | "ban" | "impersonate" | "impersonate-admins" | "set-password" | "get")[] | undefined;
                                 readonly session?: ("list" | "delete" | "revoke")[] | undefined;
                             };
-                            permission?: never | undefined;
-                        }) & {
+                        } & {
                             userId?: string | undefined;
                             role?: "user" | "admin" | "authAdmin" | "superAdmin" | "authUser" | undefined;
                         };
@@ -2457,27 +2732,27 @@ export declare const auth: import("better-auth").Auth<{
             }>;
         };
         $ERROR_CODES: {
-            readonly FAILED_TO_CREATE_USER: "Failed to create user";
-            readonly USER_ALREADY_EXISTS: "User already exists.";
-            readonly USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL: "User already exists. Use another email.";
-            readonly YOU_CANNOT_BAN_YOURSELF: "You cannot ban yourself";
-            readonly YOU_ARE_NOT_ALLOWED_TO_CHANGE_USERS_ROLE: "You are not allowed to change users role";
-            readonly YOU_ARE_NOT_ALLOWED_TO_CREATE_USERS: "You are not allowed to create users";
-            readonly YOU_ARE_NOT_ALLOWED_TO_LIST_USERS: "You are not allowed to list users";
-            readonly YOU_ARE_NOT_ALLOWED_TO_LIST_USERS_SESSIONS: "You are not allowed to list users sessions";
-            readonly YOU_ARE_NOT_ALLOWED_TO_BAN_USERS: "You are not allowed to ban users";
-            readonly YOU_ARE_NOT_ALLOWED_TO_IMPERSONATE_USERS: "You are not allowed to impersonate users";
-            readonly YOU_ARE_NOT_ALLOWED_TO_REVOKE_USERS_SESSIONS: "You are not allowed to revoke users sessions";
-            readonly YOU_ARE_NOT_ALLOWED_TO_DELETE_USERS: "You are not allowed to delete users";
-            readonly YOU_ARE_NOT_ALLOWED_TO_SET_USERS_PASSWORD: "You are not allowed to set users password";
-            readonly BANNED_USER: "You have been banned from this application";
-            readonly YOU_ARE_NOT_ALLOWED_TO_GET_USER: "You are not allowed to get user";
-            readonly NO_DATA_TO_UPDATE: "No data to update";
-            readonly YOU_ARE_NOT_ALLOWED_TO_UPDATE_USERS: "You are not allowed to update users";
-            readonly YOU_CANNOT_REMOVE_YOURSELF: "You cannot remove yourself";
-            readonly YOU_ARE_NOT_ALLOWED_TO_SET_NON_EXISTENT_VALUE: "You are not allowed to set a non-existent role value";
-            readonly YOU_CANNOT_IMPERSONATE_ADMINS: "You cannot impersonate admins";
-            readonly INVALID_ROLE_TYPE: "Invalid role type";
+            USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL: import("better-auth").RawError<"USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL">;
+            FAILED_TO_CREATE_USER: import("better-auth").RawError<"FAILED_TO_CREATE_USER">;
+            USER_ALREADY_EXISTS: import("better-auth").RawError<"USER_ALREADY_EXISTS">;
+            YOU_CANNOT_BAN_YOURSELF: import("better-auth").RawError<"YOU_CANNOT_BAN_YOURSELF">;
+            YOU_ARE_NOT_ALLOWED_TO_CHANGE_USERS_ROLE: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_CHANGE_USERS_ROLE">;
+            YOU_ARE_NOT_ALLOWED_TO_CREATE_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_CREATE_USERS">;
+            YOU_ARE_NOT_ALLOWED_TO_LIST_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_LIST_USERS">;
+            YOU_ARE_NOT_ALLOWED_TO_LIST_USERS_SESSIONS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_LIST_USERS_SESSIONS">;
+            YOU_ARE_NOT_ALLOWED_TO_BAN_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_BAN_USERS">;
+            YOU_ARE_NOT_ALLOWED_TO_IMPERSONATE_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_IMPERSONATE_USERS">;
+            YOU_ARE_NOT_ALLOWED_TO_REVOKE_USERS_SESSIONS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_REVOKE_USERS_SESSIONS">;
+            YOU_ARE_NOT_ALLOWED_TO_DELETE_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_DELETE_USERS">;
+            YOU_ARE_NOT_ALLOWED_TO_SET_USERS_PASSWORD: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_SET_USERS_PASSWORD">;
+            BANNED_USER: import("better-auth").RawError<"BANNED_USER">;
+            YOU_ARE_NOT_ALLOWED_TO_GET_USER: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_GET_USER">;
+            NO_DATA_TO_UPDATE: import("better-auth").RawError<"NO_DATA_TO_UPDATE">;
+            YOU_ARE_NOT_ALLOWED_TO_UPDATE_USERS: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_UPDATE_USERS">;
+            YOU_CANNOT_REMOVE_YOURSELF: import("better-auth").RawError<"YOU_CANNOT_REMOVE_YOURSELF">;
+            YOU_ARE_NOT_ALLOWED_TO_SET_NON_EXISTENT_VALUE: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_SET_NON_EXISTENT_VALUE">;
+            YOU_CANNOT_IMPERSONATE_ADMINS: import("better-auth").RawError<"YOU_CANNOT_IMPERSONATE_ADMINS">;
+            INVALID_ROLE_TYPE: import("better-auth").RawError<"INVALID_ROLE_TYPE">;
         };
         schema: {
             user: {
@@ -2555,11 +2830,11 @@ export declare const auth: import("better-auth").Auth<{
                     readonly "admin:user-profile": readonly ["read", "update", "list"];
                     readonly "asset_price:price": readonly ["read", "list", "latest"];
                     readonly "asset_price:admin": readonly ["create", "read", "list", "latest"];
-                    readonly "asset-type:type": readonly ["read", "update", "list"];
-                    readonly "asset_convert_product:product": readonly ["create", "read", "update", "delete", "list"];
-                    readonly "asset_convert_product:order": readonly ["create", "read", "list"];
+                    readonly "asset-type:type": readonly ["create", "read", "update", "list"];
+                    readonly "asset_convert_product:product": readonly ["create", "read", "update", "list"];
+                    readonly "asset_convert_product:order": readonly ["read", "list"];
                     readonly "asset:item": readonly ["create", "read", "update", "list"];
-                    readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
+                    readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "impersonate-admins", "delete", "set-password", "get", "update"];
                     readonly session: readonly ["list", "revoke", "delete"];
                 }>): {
                     authorize<K_1 extends K>(request: K_1 extends infer T extends K_2 ? { [key in T]?: import("better-auth/plugins").Subset<K, {
@@ -2601,11 +2876,11 @@ export declare const auth: import("better-auth").Auth<{
                         readonly "admin:user-profile": readonly ["read", "update", "list"];
                         readonly "asset_price:price": readonly ["read", "list", "latest"];
                         readonly "asset_price:admin": readonly ["create", "read", "list", "latest"];
-                        readonly "asset-type:type": readonly ["read", "update", "list"];
-                        readonly "asset_convert_product:product": readonly ["create", "read", "update", "delete", "list"];
-                        readonly "asset_convert_product:order": readonly ["create", "read", "list"];
+                        readonly "asset-type:type": readonly ["create", "read", "update", "list"];
+                        readonly "asset_convert_product:product": readonly ["create", "read", "update", "list"];
+                        readonly "asset_convert_product:order": readonly ["read", "list"];
                         readonly "asset:item": readonly ["create", "read", "update", "list"];
-                        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
+                        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "impersonate-admins", "delete", "set-password", "get", "update"];
                         readonly session: readonly ["list", "revoke", "delete"];
                     }>[key] | {
                         actions: import("better-auth/plugins").Subset<K, {
@@ -2647,11 +2922,11 @@ export declare const auth: import("better-auth").Auth<{
                             readonly "admin:user-profile": readonly ["read", "update", "list"];
                             readonly "asset_price:price": readonly ["read", "list", "latest"];
                             readonly "asset_price:admin": readonly ["create", "read", "list", "latest"];
-                            readonly "asset-type:type": readonly ["read", "update", "list"];
-                            readonly "asset_convert_product:product": readonly ["create", "read", "update", "delete", "list"];
-                            readonly "asset_convert_product:order": readonly ["create", "read", "list"];
+                            readonly "asset-type:type": readonly ["create", "read", "update", "list"];
+                            readonly "asset_convert_product:product": readonly ["create", "read", "update", "list"];
+                            readonly "asset_convert_product:order": readonly ["read", "list"];
                             readonly "asset:item": readonly ["create", "read", "update", "list"];
-                            readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
+                            readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "impersonate-admins", "delete", "set-password", "get", "update"];
                             readonly session: readonly ["list", "revoke", "delete"];
                         }>[key];
                         connector: "OR" | "AND";
@@ -2695,11 +2970,11 @@ export declare const auth: import("better-auth").Auth<{
                         readonly "admin:user-profile": readonly ["read", "update", "list"];
                         readonly "asset_price:price": readonly ["read", "list", "latest"];
                         readonly "asset_price:admin": readonly ["create", "read", "list", "latest"];
-                        readonly "asset-type:type": readonly ["read", "update", "list"];
-                        readonly "asset_convert_product:product": readonly ["create", "read", "update", "delete", "list"];
-                        readonly "asset_convert_product:order": readonly ["create", "read", "list"];
+                        readonly "asset-type:type": readonly ["create", "read", "update", "list"];
+                        readonly "asset_convert_product:product": readonly ["create", "read", "update", "list"];
+                        readonly "asset_convert_product:order": readonly ["read", "list"];
                         readonly "asset:item": readonly ["create", "read", "update", "list"];
-                        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
+                        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "impersonate-admins", "delete", "set-password", "get", "update"];
                         readonly session: readonly ["list", "revoke", "delete"];
                     }>;
                 };
@@ -2742,11 +3017,11 @@ export declare const auth: import("better-auth").Auth<{
                     readonly "admin:user-profile": readonly ["read", "update", "list"];
                     readonly "asset_price:price": readonly ["read", "list", "latest"];
                     readonly "asset_price:admin": readonly ["create", "read", "list", "latest"];
-                    readonly "asset-type:type": readonly ["read", "update", "list"];
-                    readonly "asset_convert_product:product": readonly ["create", "read", "update", "delete", "list"];
-                    readonly "asset_convert_product:order": readonly ["create", "read", "list"];
+                    readonly "asset-type:type": readonly ["create", "read", "update", "list"];
+                    readonly "asset_convert_product:product": readonly ["create", "read", "update", "list"];
+                    readonly "asset_convert_product:order": readonly ["read", "list"];
                     readonly "asset:item": readonly ["create", "read", "update", "list"];
-                    readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
+                    readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "impersonate-admins", "delete", "set-password", "get", "update"];
                     readonly session: readonly ["list", "revoke", "delete"];
                 };
             };
@@ -2756,6 +3031,7 @@ export declare const auth: import("better-auth").Auth<{
         }>;
     }, {
         id: "last-login-method";
+        version: string;
         init(ctx: import("better-auth").AuthContext): {
             options: {
                 databaseHooks: {
@@ -2803,15 +3079,16 @@ export declare const auth: import("better-auth").Auth<{
         hooks: {
             after: {
                 matcher(): true;
-                handler: (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<void>;
+                handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<void>;
             }[];
         };
         schema: undefined;
         options: NoInfer<import("better-auth/plugins").LastLoginMethodOptions>;
     }, {
         id: "multi-session";
+        version: string;
         endpoints: {
-            listDeviceSessions: import("better-auth").StrictEndpoint<"/multi-session/list-device-sessions", {
+            listDeviceSessions: import("better-call").StrictEndpoint<"/multi-session/list-device-sessions", {
                 method: "GET";
                 requireHeaders: true;
             }, {
@@ -2835,35 +3112,12 @@ export declare const auth: import("better-auth").Auth<{
                     image?: string | null | undefined;
                 };
             }[]>;
-            setActiveSession: import("better-auth").StrictEndpoint<"/multi-session/set-active", {
+            setActiveSession: import("better-call").StrictEndpoint<"/multi-session/set-active", {
                 method: "POST";
-                body: import("better-auth").ZodObject<{
-                    sessionToken: import("better-auth").ZodString;
-                }, import("better-auth").$strip>;
+                body: import("zod").ZodObject<{
+                    sessionToken: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
                 requireHeaders: true;
-                use: ((inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
-                    session: {
-                        session: Record<string, any> & {
-                            id: string;
-                            createdAt: Date;
-                            updatedAt: Date;
-                            userId: string;
-                            expiresAt: Date;
-                            token: string;
-                            ipAddress?: string | null | undefined;
-                            userAgent?: string | null | undefined;
-                        };
-                        user: Record<string, any> & {
-                            id: string;
-                            createdAt: Date;
-                            updatedAt: Date;
-                            email: string;
-                            emailVerified: boolean;
-                            name: string;
-                            image?: string | null | undefined;
-                        };
-                    };
-                }>)[];
                 metadata: {
                     openapi: {
                         description: string;
@@ -2907,13 +3161,13 @@ export declare const auth: import("better-auth").Auth<{
                     image?: string | null | undefined;
                 } & Record<string, any>;
             }>;
-            revokeDeviceSession: import("better-auth").StrictEndpoint<"/multi-session/revoke", {
+            revokeDeviceSession: import("better-call").StrictEndpoint<"/multi-session/revoke", {
                 method: "POST";
-                body: import("better-auth").ZodObject<{
-                    sessionToken: import("better-auth").ZodString;
-                }, import("better-auth").$strip>;
+                body: import("zod").ZodObject<{
+                    sessionToken: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
                 requireHeaders: true;
-                use: ((inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
                     session: {
                         session: Record<string, any> & {
                             id: string;
@@ -2965,17 +3219,18 @@ export declare const auth: import("better-auth").Auth<{
         hooks: {
             after: {
                 matcher: (context: import("better-auth").HookEndpointContext) => boolean;
-                handler: (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<void>;
+                handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<void>;
             }[];
         };
         options: import("better-auth/plugins").MultiSessionConfig | undefined;
         $ERROR_CODES: {
-            readonly INVALID_SESSION_TOKEN: "Invalid session token";
+            INVALID_SESSION_TOKEN: import("better-auth").RawError<"INVALID_SESSION_TOKEN">;
         };
     }, {
         id: "open-api";
+        version: string;
         endpoints: {
-            generateOpenAPISchema: import("better-auth").StrictEndpoint<"/open-api/generate-schema", {
+            generateOpenAPISchema: import("better-call").StrictEndpoint<"/open-api/generate-schema", {
                 method: "GET";
             }, {
                 openapi: string;
@@ -3015,7 +3270,7 @@ export declare const auth: import("better-auth").Auth<{
                 }[];
                 paths: Record<string, import("better-auth/plugins").Path>;
             }>;
-            openAPIReference: import("better-auth").StrictEndpoint<"/reference", {
+            openAPIReference: import("better-call").StrictEndpoint<import("better-auth").LiteralString | "/reference", {
                 method: "GET";
                 metadata: {
                     readonly scope: "server";