rimecms 0.31.3 → 0.31.5

package/dist/core/config/auth/better-auth.server.d.ts

@@ -8,37 +8,44 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
     readonly baseURL: any;
     readonly plugins: ({
         id: "api-key";
+        version: string;
         $ERROR_CODES: {
-            readonly INVALID_METADATA_TYPE: "metadata must be an object or undefined";
-            readonly REFILL_AMOUNT_AND_INTERVAL_REQUIRED: "refillAmount is required when refillInterval is provided";
-            readonly REFILL_INTERVAL_AND_AMOUNT_REQUIRED: "refillInterval is required when refillAmount is provided";
-            readonly USER_BANNED: "User is banned";
-            readonly UNAUTHORIZED_SESSION: "Unauthorized or invalid session";
-            readonly KEY_NOT_FOUND: "API Key not found";
-            readonly KEY_DISABLED: "API Key is disabled";
-            readonly KEY_EXPIRED: "API Key has expired";
-            readonly USAGE_EXCEEDED: "API Key has reached its usage limit";
-            readonly KEY_NOT_RECOVERABLE: "API Key is not recoverable";
-            readonly EXPIRES_IN_IS_TOO_SMALL: "The expiresIn is smaller than the predefined minimum value.";
-            readonly EXPIRES_IN_IS_TOO_LARGE: "The expiresIn is larger than the predefined maximum value.";
-            readonly INVALID_REMAINING: "The remaining count is either too large or too small.";
-            readonly INVALID_PREFIX_LENGTH: "The prefix length is either too large or too small.";
-            readonly INVALID_NAME_LENGTH: "The name length is either too large or too small.";
-            readonly METADATA_DISABLED: "Metadata is disabled.";
-            readonly RATE_LIMIT_EXCEEDED: "Rate limit exceeded.";
-            readonly NO_VALUES_TO_UPDATE: "No values to update.";
-            readonly KEY_DISABLED_EXPIRATION: "Custom key expiration values are disabled.";
-            readonly INVALID_API_KEY: "Invalid API key.";
-            readonly INVALID_USER_ID_FROM_API_KEY: "The user id from the API key is invalid.";
-            readonly INVALID_API_KEY_GETTER_RETURN_TYPE: "API Key getter returned an invalid key type. Expected string.";
-            readonly SERVER_ONLY_PROPERTY: "The property you're trying to set can only be set from the server auth instance only.";
-            readonly FAILED_TO_UPDATE_API_KEY: "Failed to update API key";
-            readonly NAME_REQUIRED: "API Key name is required.";
+            INVALID_METADATA_TYPE: import("better-auth").RawError<"INVALID_METADATA_TYPE">;
+            REFILL_AMOUNT_AND_INTERVAL_REQUIRED: import("better-auth").RawError<"REFILL_AMOUNT_AND_INTERVAL_REQUIRED">;
+            REFILL_INTERVAL_AND_AMOUNT_REQUIRED: import("better-auth").RawError<"REFILL_INTERVAL_AND_AMOUNT_REQUIRED">;
+            USER_BANNED: import("better-auth").RawError<"USER_BANNED">;
+            UNAUTHORIZED_SESSION: import("better-auth").RawError<"UNAUTHORIZED_SESSION">;
+            KEY_NOT_FOUND: import("better-auth").RawError<"KEY_NOT_FOUND">;
+            KEY_DISABLED: import("better-auth").RawError<"KEY_DISABLED">;
+            KEY_EXPIRED: import("better-auth").RawError<"KEY_EXPIRED">;
+            USAGE_EXCEEDED: import("better-auth").RawError<"USAGE_EXCEEDED">;
+            KEY_NOT_RECOVERABLE: import("better-auth").RawError<"KEY_NOT_RECOVERABLE">;
+            EXPIRES_IN_IS_TOO_SMALL: import("better-auth").RawError<"EXPIRES_IN_IS_TOO_SMALL">;
+            EXPIRES_IN_IS_TOO_LARGE: import("better-auth").RawError<"EXPIRES_IN_IS_TOO_LARGE">;
+            INVALID_REMAINING: import("better-auth").RawError<"INVALID_REMAINING">;
+            INVALID_PREFIX_LENGTH: import("better-auth").RawError<"INVALID_PREFIX_LENGTH">;
+            INVALID_NAME_LENGTH: import("better-auth").RawError<"INVALID_NAME_LENGTH">;
+            METADATA_DISABLED: import("better-auth").RawError<"METADATA_DISABLED">;
+            RATE_LIMIT_EXCEEDED: import("better-auth").RawError<"RATE_LIMIT_EXCEEDED">;
+            NO_VALUES_TO_UPDATE: import("better-auth").RawError<"NO_VALUES_TO_UPDATE">;
+            KEY_DISABLED_EXPIRATION: import("better-auth").RawError<"KEY_DISABLED_EXPIRATION">;
+            INVALID_API_KEY: import("better-auth").RawError<"INVALID_API_KEY">;
+            INVALID_USER_ID_FROM_API_KEY: import("better-auth").RawError<"INVALID_USER_ID_FROM_API_KEY">;
+            INVALID_REFERENCE_ID_FROM_API_KEY: import("better-auth").RawError<"INVALID_REFERENCE_ID_FROM_API_KEY">;
+            INVALID_API_KEY_GETTER_RETURN_TYPE: import("better-auth").RawError<"INVALID_API_KEY_GETTER_RETURN_TYPE">;
+            SERVER_ONLY_PROPERTY: import("better-auth").RawError<"SERVER_ONLY_PROPERTY">;
+            FAILED_TO_UPDATE_API_KEY: import("better-auth").RawError<"FAILED_TO_UPDATE_API_KEY">;
+            NAME_REQUIRED: import("better-auth").RawError<"NAME_REQUIRED">;
+            ORGANIZATION_ID_REQUIRED: import("better-auth").RawError<"ORGANIZATION_ID_REQUIRED">;
+            USER_NOT_MEMBER_OF_ORGANIZATION: import("better-auth").RawError<"USER_NOT_MEMBER_OF_ORGANIZATION">;
+            INSUFFICIENT_API_KEY_PERMISSIONS: import("better-auth").RawError<"INSUFFICIENT_API_KEY_PERMISSIONS">;
+            NO_DEFAULT_API_KEY_CONFIGURATION_FOUND: import("better-auth").RawError<"NO_DEFAULT_API_KEY_CONFIGURATION_FOUND">;
+            ORGANIZATION_PLUGIN_REQUIRED: import("better-auth").RawError<"ORGANIZATION_PLUGIN_REQUIRED">;
         };
         hooks: {
             before: {
-                matcher: (ctx: import("better-auth/*").HookEndpointContext) => boolean;
-                handler: (inputContext: import("better-auth/*").MiddlewareInputContext<import("better-auth/*").MiddlewareOptions>) => Promise<{
+                matcher: (ctx: import("better-auth").HookEndpointContext) => boolean;
+                handler: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
                     user: {
                         id: string;
                         createdAt: Date;
@@ -59,14 +66,10 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
                         expiresAt: Date;
                     };
                 } | {
-                    context: import("better-auth/*").MiddlewareContext<import("better-auth/*").MiddlewareOptions, {
-                        returned?: unknown | undefined;
-                        responseHeaders?: Headers | undefined;
-                    } & import("better-auth/*").PluginContext & import("better-auth/*").InfoContext & {
-                        options: import("better-auth/types").BetterAuthOptions;
-                        appName: string;
-                        baseURL: string;
+                    context: import("better-call").MiddlewareContext<import("better-call").MiddlewareOptions, import("better-auth").PluginContext<import("better-auth").BetterAuthOptions> & import("better-auth").InfoContext & {
+                        options: import("better-auth").BetterAuthOptions;
                         trustedOrigins: string[];
+                        trustedProviders: string[];
                         isTrustedOrigin: (url: string, settings?: {
                             allowRelativePaths: boolean;
                         }) => boolean;
@@ -75,44 +78,97 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
                             storeStateStrategy: "database" | "cookie";
                         };
                         newSession: {
-                            session: import("better-auth/types").Session & Record<string, any>;
-                            user: import("better-auth/types").User & Record<string, any>;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            } & Record<string, any>;
+                            user: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                email: string;
+                                emailVerified: boolean;
+                                name: string;
+                                image?: string | null | undefined;
+                            } & Record<string, any>;
                         } | null;
                         session: {
-                            session: import("better-auth/types").Session & Record<string, any>;
-                            user: import("better-auth/types").User & Record<string, any>;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            } & Record<string, any>;
+                            user: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                email: string;
+                                emailVerified: boolean;
+                                name: string;
+                                image?: string | null | undefined;
+                            } & Record<string, any>;
                         } | null;
                         setNewSession: (session: {
-                            session: import("better-auth/types").Session & Record<string, any>;
-                            user: import("better-auth/types").User & Record<string, any>;
+                            session: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                userId: string;
+                                expiresAt: Date;
+                                token: string;
+                                ipAddress?: string | null | undefined;
+                                userAgent?: string | null | undefined;
+                            } & Record<string, any>;
+                            user: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                email: string;
+                                emailVerified: boolean;
+                                name: string;
+                                image?: string | null | undefined;
+                            } & Record<string, any>;
                         } | null) => void;
-                        socialProviders: import("better-auth/*").OAuthProvider[];
-                        authCookies: import("better-auth/types").BetterAuthCookies;
-                        logger: ReturnType<(options?: import("better-auth/*").Logger | undefined) => import("better-auth/*").InternalLogger>;
+                        socialProviders: import("better-auth").OAuthProvider[];
+                        authCookies: import("better-auth").BetterAuthCookies;
+                        logger: ReturnType<(options?: import("better-auth").Logger | undefined) => import("better-auth").InternalLogger>;
                         rateLimit: {
                             enabled: boolean;
                             window: number;
                             max: number;
                             storage: "memory" | "database" | "secondary-storage";
-                        } & Omit<import("better-auth/types").BetterAuthRateLimitOptions, "enabled" | "window" | "max" | "storage">;
-                        adapter: import("better-auth/types").DBAdapter<import("better-auth/types").BetterAuthOptions>;
-                        internalAdapter: import("better-auth/*").InternalAdapter<import("better-auth/types").BetterAuthOptions>;
-                        createAuthCookie: (cookieName: string, overrideAttributes?: Partial<import("better-auth/*").CookieOptions> | undefined) => import("better-auth/*").BetterAuthCookie;
+                        } & Omit<import("better-auth").BetterAuthRateLimitOptions, "enabled" | "window" | "max" | "storage">;
+                        adapter: import("better-auth").DBAdapter<import("better-auth").BetterAuthOptions>;
+                        internalAdapter: import("better-auth").InternalAdapter<import("better-auth").BetterAuthOptions>;
+                        createAuthCookie: (cookieName: string, overrideAttributes?: Partial<import("better-call").CookieOptions> | undefined) => import("better-auth").BetterAuthCookie;
                         secret: string;
+                        secretConfig: string | import("better-auth").SecretConfig;
                         sessionConfig: {
                             updateAge: number;
                             expiresIn: number;
                             freshAge: number;
+                            cookieCacheSigner?: import("better-auth").CookieCacheSigner | undefined;
                             cookieRefreshCache: false | {
                                 enabled: true;
                                 updateAge: number;
                             };
                         };
                         generateId: (options: {
-                            model: import("better-auth/db").ModelNames;
+                            model: import("better-auth").ModelNames;
                             size?: number | undefined;
                         }) => string | false;
-                        secondaryStorage: import("better-auth/db").SecondaryStorage | undefined;
+                        secondaryStorage: import("better-auth").SecondaryStorage | undefined;
                         password: {
                             hash: (password: string) => Promise<string>;
                             verify: (data: {
@@ -123,9 +179,9 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
                                 minPasswordLength: number;
                                 maxPasswordLength: number;
                             };
-                            checkPassword: (userId: string, ctx: import("better-auth/*").GenericEndpointContext<import("better-auth/types").BetterAuthOptions>) => Promise<boolean>;
+                            checkPassword: (userId: string, ctx: import("better-auth").GenericEndpointContext<import("better-auth").BetterAuthOptions>) => Promise<boolean>;
                         };
-                        tables: import("better-auth/db").BetterAuthDBSchema;
+                        tables: import("better-auth").BetterAuthDBSchema;
                         runMigrations: () => Promise<void>;
                         publishTelemetry: (event: {
                             type: string;
@@ -135,28 +191,33 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
                         skipOriginCheck: boolean | string[];
                         skipCSRFCheck: boolean;
                         runInBackground: (promise: Promise<unknown>) => void;
-                        runInBackgroundOrAwait: (promise: Promise<unknown> | void) => import("better-auth/*").Awaitable<unknown>;
+                        runInBackgroundOrAwait: (promise: Promise<unknown> | void) => import("better-auth").Awaitable<unknown>;
+                    } & {
+                        returned?: unknown | undefined;
+                        responseHeaders?: Headers | undefined;
                     }>;
-                }>;
+                }>>;
             }[];
         };
         endpoints: {
-            createApiKey: import("better-auth/*").StrictEndpoint<"/api-key/create", {
+            createApiKey: import("better-call").StrictEndpoint<"/api-key/create", {
                 method: "POST";
-                body: import("better-auth/*").ZodObject<{
-                    name: import("better-auth/*").ZodOptional<import("better-auth/*").ZodString>;
-                    expiresIn: import("better-auth/*").ZodDefault<import("better-auth/*").ZodNullable<import("better-auth/*").ZodOptional<import("better-auth/*").ZodNumber>>>;
-                    userId: import("better-auth/*").ZodOptional<import("better-auth/*").ZodCoercedString<unknown>>;
-                    prefix: import("better-auth/*").ZodOptional<import("better-auth/*").ZodString>;
-                    remaining: import("better-auth/*").ZodDefault<import("better-auth/*").ZodNullable<import("better-auth/*").ZodOptional<import("better-auth/*").ZodNumber>>>;
-                    metadata: import("better-auth/*").ZodOptional<import("better-auth/*").ZodAny>;
-                    refillAmount: import("better-auth/*").ZodOptional<import("better-auth/*").ZodNumber>;
-                    refillInterval: import("better-auth/*").ZodOptional<import("better-auth/*").ZodNumber>;
-                    rateLimitTimeWindow: import("better-auth/*").ZodOptional<import("better-auth/*").ZodNumber>;
-                    rateLimitMax: import("better-auth/*").ZodOptional<import("better-auth/*").ZodNumber>;
-                    rateLimitEnabled: import("better-auth/*").ZodOptional<import("better-auth/*").ZodBoolean>;
-                    permissions: import("better-auth/*").ZodOptional<import("better-auth/*").ZodRecord<import("better-auth/*").ZodString, import("better-auth/*").ZodArray<import("better-auth/*").ZodString>>>;
-                }, import("better-auth/*").$strip>;
+                body: import("zod").ZodObject<{
+                    configId: import("zod").ZodOptional<import("zod").ZodString>;
+                    name: import("zod").ZodOptional<import("zod").ZodString>;
+                    expiresIn: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodNumber>>>;
+                    prefix: import("zod").ZodOptional<import("zod").ZodString>;
+                    remaining: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodNumber>>>;
+                    metadata: import("zod").ZodOptional<import("zod").ZodAny>;
+                    refillAmount: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    refillInterval: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    rateLimitTimeWindow: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    rateLimitMax: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    rateLimitEnabled: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    permissions: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>>>;
+                    userId: import("zod").ZodOptional<import("zod").ZodCoercedString<unknown>>;
+                    organizationId: import("zod").ZodOptional<import("zod").ZodCoercedString<unknown>>;
+                }, import("zod/v4/core").$strip>;
                 metadata: {
                     openapi: {
                         description: string;
@@ -211,7 +272,7 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
                                                     nullable: boolean;
                                                     description: string;
                                                 };
-                                                userId: {
+                                                referenceId: {
                                                     type: string;
                                                     description: string;
                                                 };
@@ -291,10 +352,11 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
                 metadata: any;
                 permissions: any;
                 id: string;
+                configId: string;
                 name: string | null;
                 start: string | null;
                 prefix: string | null;
-                userId: string;
+                referenceId: string;
                 refillInterval: number | null;
                 refillAmount: number | null;
                 lastRefillAt: Date | null;
@@ -309,16 +371,17 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
                 createdAt: Date;
                 updatedAt: Date;
             }>;
-            verifyApiKey: import("better-auth/*").StrictEndpoint<string, {
+            verifyApiKey: import("better-call").StrictEndpoint<string, {
                 method: "POST";
-                body: import("better-auth/*").ZodObject<{
-                    key: import("better-auth/*").ZodString;
-                    permissions: import("better-auth/*").ZodOptional<import("better-auth/*").ZodRecord<import("better-auth/*").ZodString, import("better-auth/*").ZodArray<import("better-auth/*").ZodString>>>;
-                }, import("better-auth/*").$strip>;
+                body: import("zod").ZodObject<{
+                    configId: import("zod").ZodOptional<import("zod").ZodString>;
+                    key: import("zod").ZodString;
+                    permissions: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>>>;
+                }, import("zod/v4/core").$strip>;
             }, {
                 valid: boolean;
                 error: {
-                    message: "Invalid API key.";
+                    message: import("better-auth").RawError<"INVALID_API_KEY">;
                     code: "KEY_NOT_FOUND";
                 };
                 key: null;
@@ -333,21 +396,22 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
             } | {
                 valid: boolean;
                 error: {
-                    message: "Invalid API key.";
+                    message: import("better-auth").RawError<"INVALID_API_KEY">;
                     code: "INVALID_API_KEY";
                 };
                 key: null;
             } | {
                 valid: boolean;
                 error: null;
-                key: Omit<import("better-auth/plugins").ApiKey, "key"> | null;
+                key: Omit<import("@better-auth/api-key").ApiKey, "key"> | null;
             }>;
-            getApiKey: import("better-auth/*").StrictEndpoint<"/api-key/get", {
+            getApiKey: import("better-call").StrictEndpoint<"/api-key/get", {
                 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<{
+                    configId: import("zod").ZodOptional<import("zod").ZodString>;
+                    id: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+                use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
                     session: {
                         session: Record<string, any> & {
                             id: string;
@@ -369,7 +433,7 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
                             image?: string | null | undefined;
                         };
                     };
-                }>)[];
+                }>>[];
                 metadata: {
                     openapi: {
                         description: string;
@@ -496,10 +560,11 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
                     [key: string]: string[];
                 } | null;
                 id: string;
+                configId: string;
                 name: string | null;
                 start: string | null;
                 prefix: string | null;
-                userId: string;
+                referenceId: string;
                 refillInterval: number | null;
                 refillAmount: number | null;
                 lastRefillAt: Date | null;
@@ -514,23 +579,24 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
                 createdAt: Date;
                 updatedAt: Date;
             }>;
-            updateApiKey: import("better-auth/*").StrictEndpoint<"/api-key/update", {
+            updateApiKey: import("better-call").StrictEndpoint<"/api-key/update", {
                 method: "POST";
-                body: import("better-auth/*").ZodObject<{
-                    keyId: import("better-auth/*").ZodString;
-                    userId: import("better-auth/*").ZodOptional<import("better-auth/*").ZodCoercedString<unknown>>;
-                    name: import("better-auth/*").ZodOptional<import("better-auth/*").ZodString>;
-                    enabled: import("better-auth/*").ZodOptional<import("better-auth/*").ZodBoolean>;
-                    remaining: import("better-auth/*").ZodOptional<import("better-auth/*").ZodNumber>;
-                    refillAmount: import("better-auth/*").ZodOptional<import("better-auth/*").ZodNumber>;
-                    refillInterval: import("better-auth/*").ZodOptional<import("better-auth/*").ZodNumber>;
-                    metadata: import("better-auth/*").ZodOptional<import("better-auth/*").ZodAny>;
-                    expiresIn: import("better-auth/*").ZodNullable<import("better-auth/*").ZodOptional<import("better-auth/*").ZodNumber>>;
-                    rateLimitEnabled: import("better-auth/*").ZodOptional<import("better-auth/*").ZodBoolean>;
-                    rateLimitTimeWindow: import("better-auth/*").ZodOptional<import("better-auth/*").ZodNumber>;
-                    rateLimitMax: import("better-auth/*").ZodOptional<import("better-auth/*").ZodNumber>;
-                    permissions: import("better-auth/*").ZodNullable<import("better-auth/*").ZodOptional<import("better-auth/*").ZodRecord<import("better-auth/*").ZodString, import("better-auth/*").ZodArray<import("better-auth/*").ZodString>>>>;
-                }, import("better-auth/*").$strip>;
+                body: import("zod").ZodObject<{
+                    configId: import("zod").ZodOptional<import("zod").ZodString>;
+                    keyId: import("zod").ZodString;
+                    userId: import("zod").ZodOptional<import("zod").ZodCoercedString<unknown>>;
+                    name: import("zod").ZodOptional<import("zod").ZodString>;
+                    enabled: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    remaining: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    refillAmount: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    refillInterval: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    metadata: import("zod").ZodOptional<import("zod").ZodAny>;
+                    expiresIn: import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodNumber>>;
+                    rateLimitEnabled: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    rateLimitTimeWindow: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    rateLimitMax: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    permissions: import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>>>>;
+                }, import("zod/v4/core").$strip>;
                 metadata: {
                     openapi: {
                         description: string;
@@ -657,10 +723,11 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
                     [key: string]: string[];
                 } | null;
                 id: string;
+                configId: string;
                 name: string | null;
                 start: string | null;
                 prefix: string | null;
-                userId: string;
+                referenceId: string;
                 refillInterval: number | null;
                 refillAmount: number | null;
                 lastRefillAt: Date | null;
@@ -675,12 +742,13 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
                 createdAt: Date;
                 updatedAt: Date;
             }>;
-            deleteApiKey: import("better-auth/*").StrictEndpoint<"/api-key/delete", {
+            deleteApiKey: import("better-call").StrictEndpoint<"/api-key/delete", {
                 method: "POST";
-                body: import("better-auth/*").ZodObject<{
-                    keyId: import("better-auth/*").ZodString;
-                }, import("better-auth/*").$strip>;
-                use: ((inputContext: import("better-auth/*").MiddlewareInputContext<import("better-auth/*").MiddlewareOptions>) => Promise<{
+                body: import("zod").ZodObject<{
+                    configId: import("zod").ZodOptional<import("zod").ZodString>;
+                    keyId: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+                use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
                     session: {
                         session: Record<string, any> & {
                             id: string;
@@ -702,7 +770,7 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
                             image?: string | null | undefined;
                         };
                     };
-                }>)[];
+                }>>[];
                 metadata: {
                     openapi: {
                         description: string;
@@ -746,9 +814,9 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
             }, {
                 success: boolean;
             }>;
-            listApiKeys: import("better-auth/*").StrictEndpoint<"/api-key/list", {
+            listApiKeys: import("better-call").StrictEndpoint<"/api-key/list", {
                 method: "GET";
-                use: ((inputContext: import("better-auth/*").MiddlewareInputContext<import("better-auth/*").MiddlewareOptions>) => Promise<{
+                use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
                     session: {
                         session: Record<string, any> & {
                             id: string;
@@ -770,7 +838,18 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
                             image?: string | null | undefined;
                         };
                     };
-                }>)[];
+                }>>[];
+                query: import("zod").ZodOptional<import("zod").ZodObject<{
+                    configId: import("zod").ZodOptional<import("zod").ZodString>;
+                    organizationId: import("zod").ZodOptional<import("zod").ZodString>;
+                    limit: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
+                    offset: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
+                    sortBy: import("zod").ZodOptional<import("zod").ZodString>;
+                    sortDirection: import("zod").ZodOptional<import("zod").ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>>;
+                }, import("zod/v4/core").$strip>>;
                 metadata: {
                     openapi: {
                         description: string;
@@ -780,113 +859,133 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
                                 content: {
                                     "application/json": {
                                         schema: {
-                                            type: "array";
-                                            items: {
-                                                type: string;
-                                                properties: {
-                                                    id: {
-                                                        type: string;
-                                                        description: string;
-                                                    };
-                                                    name: {
-                                                        type: string;
-                                                        nullable: boolean;
-                                                        description: string;
-                                                    };
-                                                    start: {
-                                                        type: string;
-                                                        nullable: boolean;
-                                                        description: string;
-                                                    };
-                                                    prefix: {
-                                                        type: string;
-                                                        nullable: boolean;
-                                                        description: string;
-                                                    };
-                                                    userId: {
-                                                        type: string;
-                                                        description: string;
-                                                    };
-                                                    refillInterval: {
-                                                        type: string;
-                                                        nullable: boolean;
-                                                        description: string;
-                                                    };
-                                                    refillAmount: {
-                                                        type: string;
-                                                        nullable: boolean;
-                                                        description: string;
-                                                    };
-                                                    lastRefillAt: {
-                                                        type: string;
-                                                        format: string;
-                                                        nullable: boolean;
-                                                        description: string;
-                                                    };
-                                                    enabled: {
-                                                        type: string;
-                                                        description: string;
-                                                        default: boolean;
-                                                    };
-                                                    rateLimitEnabled: {
-                                                        type: string;
-                                                        description: string;
-                                                    };
-                                                    rateLimitTimeWindow: {
-                                                        type: string;
-                                                        nullable: boolean;
-                                                        description: string;
-                                                    };
-                                                    rateLimitMax: {
-                                                        type: string;
-                                                        nullable: boolean;
-                                                        description: string;
-                                                    };
-                                                    requestCount: {
-                                                        type: string;
-                                                        description: string;
-                                                    };
-                                                    remaining: {
-                                                        type: string;
-                                                        nullable: boolean;
-                                                        description: string;
-                                                    };
-                                                    lastRequest: {
-                                                        type: string;
-                                                        format: string;
-                                                        nullable: boolean;
-                                                        description: string;
-                                                    };
-                                                    expiresAt: {
-                                                        type: string;
-                                                        format: string;
-                                                        nullable: boolean;
-                                                        description: string;
-                                                    };
-                                                    createdAt: {
-                                                        type: string;
-                                                        format: string;
-                                                        description: string;
-                                                    };
-                                                    updatedAt: {
-                                                        type: string;
-                                                        format: string;
-                                                        description: string;
-                                                    };
-                                                    metadata: {
-                                                        type: string;
-                                                        nullable: boolean;
-                                                        additionalProperties: boolean;
-                                                        description: string;
-                                                    };
-                                                    permissions: {
+                                            type: "object";
+                                            properties: {
+                                                apiKeys: {
+                                                    type: string;
+                                                    items: {
                                                         type: string;
-                                                        nullable: boolean;
-                                                        description: string;
+                                                        properties: {
+                                                            id: {
+                                                                type: string;
+                                                                description: string;
+                                                            };
+                                                            name: {
+                                                                type: string;
+                                                                nullable: boolean;
+                                                                description: string;
+                                                            };
+                                                            start: {
+                                                                type: string;
+                                                                nullable: boolean;
+                                                                description: string;
+                                                            };
+                                                            prefix: {
+                                                                type: string;
+                                                                nullable: boolean;
+                                                                description: string;
+                                                            };
+                                                            userId: {
+                                                                type: string;
+                                                                description: string;
+                                                            };
+                                                            refillInterval: {
+                                                                type: string;
+                                                                nullable: boolean;
+                                                                description: string;
+                                                            };
+                                                            refillAmount: {
+                                                                type: string;
+                                                                nullable: boolean;
+                                                                description: string;
+                                                            };
+                                                            lastRefillAt: {
+                                                                type: string;
+                                                                format: string;
+                                                                nullable: boolean;
+                                                                description: string;
+                                                            };
+                                                            enabled: {
+                                                                type: string;
+                                                                description: string;
+                                                                default: boolean;
+                                                            };
+                                                            rateLimitEnabled: {
+                                                                type: string;
+                                                                description: string;
+                                                            };
+                                                            rateLimitTimeWindow: {
+                                                                type: string;
+                                                                nullable: boolean;
+                                                                description: string;
+                                                            };
+                                                            rateLimitMax: {
+                                                                type: string;
+                                                                nullable: boolean;
+                                                                description: string;
+                                                            };
+                                                            requestCount: {
+                                                                type: string;
+                                                                description: string;
+                                                            };
+                                                            remaining: {
+                                                                type: string;
+                                                                nullable: boolean;
+                                                                description: string;
+                                                            };
+                                                            lastRequest: {
+                                                                type: string;
+                                                                format: string;
+                                                                nullable: boolean;
+                                                                description: string;
+                                                            };
+                                                            expiresAt: {
+                                                                type: string;
+                                                                format: string;
+                                                                nullable: boolean;
+                                                                description: string;
+                                                            };
+                                                            createdAt: {
+                                                                type: string;
+                                                                format: string;
+                                                                description: string;
+                                                            };
+                                                            updatedAt: {
+                                                                type: string;
+                                                                format: string;
+                                                                description: string;
+                                                            };
+                                                            metadata: {
+                                                                type: string;
+                                                                nullable: boolean;
+                                                                additionalProperties: boolean;
+                                                                description: string;
+                                                            };
+                                                            permissions: {
+                                                                type: string;
+                                                                nullable: boolean;
+                                                                description: string;
+                                                            };
+                                                        };
+                                                        required: string[];
                                                     };
                                                 };
-                                                required: string[];
+                                                total: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                limit: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
+                                                offset: {
+                                                    type: string;
+                                                    nullable: boolean;
+                                                    description: string;
+                                                };
                                             };
+                                            required: string[];
                                         };
                                     };
                                 };
@@ -895,30 +994,36 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
                     };
                 };
             }, {
-                metadata: Record<string, any> | null;
-                permissions: {
-                    [key: string]: string[];
-                } | null;
-                id: string;
-                name: string | null;
-                start: string | null;
-                prefix: string | null;
-                userId: string;
-                refillInterval: number | null;
-                refillAmount: number | null;
-                lastRefillAt: Date | null;
-                enabled: boolean;
-                rateLimitEnabled: boolean;
-                rateLimitTimeWindow: number | null;
-                rateLimitMax: number | null;
-                requestCount: number;
-                remaining: number | null;
-                lastRequest: Date | null;
-                expiresAt: Date | null;
-                createdAt: Date;
-                updatedAt: Date;
-            }[]>;
-            deleteAllExpiredApiKeys: import("better-auth/*").StrictEndpoint<string, {
+                apiKeys: {
+                    metadata: Record<string, any> | null;
+                    permissions: {
+                        [key: string]: string[];
+                    } | null;
+                    id: string;
+                    configId: string;
+                    name: string | null;
+                    start: string | null;
+                    prefix: string | null;
+                    referenceId: string;
+                    refillInterval: number | null;
+                    refillAmount: number | null;
+                    lastRefillAt: Date | null;
+                    enabled: boolean;
+                    rateLimitEnabled: boolean;
+                    rateLimitTimeWindow: number | null;
+                    rateLimitMax: number | null;
+                    requestCount: number;
+                    remaining: number | null;
+                    lastRequest: Date | null;
+                    expiresAt: Date | null;
+                    createdAt: Date;
+                    updatedAt: Date;
+                }[];
+                total: number;
+                limit: number | undefined;
+                offset: number | undefined;
+            }>;
+            deleteAllExpiredApiKeys: import("better-call").StrictEndpoint<string, {
                 method: "POST";
             }, {
                 success: boolean;
@@ -928,34 +1033,36 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
         schema: {
             apikey: {
                 fields: {
-                    name: {
+                    configId: {
                         type: "string";
-                        required: false;
+                        required: true;
+                        defaultValue: string;
                         input: false;
+                        index: true;
                     };
-                    start: {
+                    name: {
                         type: "string";
                         required: false;
                         input: false;
                     };
-                    prefix: {
+                    start: {
                         type: "string";
                         required: false;
                         input: false;
                     };
-                    key: {
+                    referenceId: {
                         type: "string";
                         required: true;
                         input: false;
                         index: true;
                     };
-                    userId: {
+                    prefix: {
+                        type: "string";
+                        required: false;
+                        input: false;
+                    };
+                    key: {
                         type: "string";
-                        references: {
-                            model: string;
-                            field: string;
-                            onDelete: "cascade";
-                        };
                         required: true;
                         input: false;
                         index: true;
@@ -1040,16 +1147,16 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
                         required: false;
                         input: true;
                         transform: {
-                            input(value: import("better-auth/db").DBPrimitive): string;
-                            output(value: import("better-auth/db").DBPrimitive): any;
+                            input(value: import("better-auth").DBPrimitive): string;
+                            output(value: import("better-auth").DBPrimitive): any;
                         };
                     };
                 };
             };
         };
-        options: import("better-auth/plugins").ApiKeyOptions | undefined;
     } | {
         id: "admin";
+        version: string;
         init(): {
             options: {
                 databaseHooks: {
@@ -1088,7 +1195,7 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
                                 token: string;
                                 ipAddress?: string | null | undefined;
                                 userAgent?: string | null | undefined;
-                            } & Record<string, unknown>, ctx: import("better-auth/*").GenericEndpointContext | null): Promise<void>;
+                            } & Record<string, unknown>, ctx: import("better-auth").GenericEndpointContext | null): Promise<void>;
                         };
                     };
                 };
@@ -1096,24 +1203,33 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
         };
         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>;
+                matcher(context: import("better-auth").HookEndpointContext): boolean;
+                handler: import("better-call").Middleware<import("better-call").MiddlewareOptions, (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: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
                     session: {
                         user: import("better-auth/plugins").UserWithRole;
-                        session: import("better-auth/types").Session;
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
                     };
-                }>)[];
+                }>>[];
                 metadata: {
                     openapi: {
                         operationId: string;
@@ -1147,17 +1263,26 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
             }, {
                 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: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
                     session: {
                         user: import("better-auth/plugins").UserWithRole;
-                        session: import("better-auth/types").Session;
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
                     };
-                }>)[];
+                }>>[];
                 metadata: {
                     openapi: {
                         operationId: string;
@@ -1183,15 +1308,15 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
                     };
                 };
             }, 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;
@@ -1228,18 +1353,27 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
             }, {
                 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: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
                     session: {
                         user: import("better-auth/plugins").UserWithRole;
-                        session: import("better-auth/types").Session;
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
                     };
-                }>)[];
+                }>>[];
                 metadata: {
                     openapi: {
                         operationId: string;
@@ -1265,44 +1399,57 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
                     };
                 };
             }, 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: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
                     session: {
                         user: import("better-auth/plugins").UserWithRole;
-                        session: import("better-auth/types").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;
@@ -1344,17 +1491,26 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
                 users: import("better-auth/plugins").UserWithRole[];
                 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: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
                     session: {
                         user: import("better-auth/plugins").UserWithRole;
-                        session: import("better-auth/types").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;
@@ -1385,17 +1541,26 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
             }, {
                 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: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
                     session: {
                         user: import("better-auth/plugins").UserWithRole;
-                        session: import("better-auth/types").Session;
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
                     };
-                }>)[];
+                }>>[];
                 metadata: {
                     openapi: {
                         operationId: string;
@@ -1423,19 +1588,28 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
             }, {
                 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: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
                     session: {
                         user: import("better-auth/plugins").UserWithRole;
-                        session: import("better-auth/types").Session;
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
                     };
-                }>)[];
+                }>>[];
                 metadata: {
                     openapi: {
                         operationId: string;
@@ -1463,17 +1637,26 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
             }, {
                 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: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
                     session: {
                         user: import("better-auth/plugins").UserWithRole;
-                        session: import("better-auth/types").Session;
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
                     };
-                }>)[];
+                }>>[];
                 metadata: {
                     openapi: {
                         operationId: string;
@@ -1514,7 +1697,7 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
                 };
                 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;
             }, {
@@ -1538,17 +1721,26 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
                     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: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
                     session: {
                         user: import("better-auth/plugins").UserWithRole;
-                        session: import("better-auth/types").Session;
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
                     };
-                }>)[];
+                }>>[];
                 metadata: {
                     openapi: {
                         operationId: string;
@@ -1576,17 +1768,26 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
             }, {
                 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: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
                     session: {
                         user: import("better-auth/plugins").UserWithRole;
-                        session: import("better-auth/types").Session;
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
                     };
-                }>)[];
+                }>>[];
                 metadata: {
                     openapi: {
                         operationId: string;
@@ -1614,17 +1815,26 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
             }, {
                 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: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
                     session: {
                         user: import("better-auth/plugins").UserWithRole;
-                        session: import("better-auth/types").Session;
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
                     };
-                }>)[];
+                }>>[];
                 metadata: {
                     openapi: {
                         operationId: string;
@@ -1652,18 +1862,27 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
             }, {
                 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: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
                     session: {
                         user: import("better-auth/plugins").UserWithRole;
-                        session: import("better-auth/types").Session;
+                        session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
                     };
-                }>)[];
+                }>>[];
                 metadata: {
                     openapi: {
                         operationId: string;
@@ -1691,18 +1910,16 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
             }, {
                 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;
@@ -1712,11 +1929,6 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
                                     schema: {
                                         type: "object";
                                         properties: {
-                                            permission: {
-                                                type: string;
-                                                description: string;
-                                                deprecated: boolean;
-                                            };
                                             permissions: {
                                                 type: string;
                                                 description: string;
@@ -1750,19 +1962,12 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
                         };
                     };
                     $Infer: {
-                        body: ({
-                            permission: {
-                                readonly user?: ("create" | "update" | "delete" | "list" | "get" | "set-role" | "ban" | "impersonate" | "set-password")[] | undefined;
-                                readonly session?: ("delete" | "list" | "revoke")[] | undefined;
-                            };
-                            permissions?: never | undefined;
-                        } | {
+                        body: {
                             permissions: {
-                                readonly user?: ("create" | "update" | "delete" | "list" | "get" | "set-role" | "ban" | "impersonate" | "set-password")[] | undefined;
+                                readonly user?: ("create" | "update" | "delete" | "list" | "get" | "set-role" | "ban" | "impersonate" | "impersonate-admins" | "set-password" | "set-email")[] | undefined;
                                 readonly session?: ("delete" | "list" | "revoke")[] | undefined;
                             };
-                            permission?: never | undefined;
-                        }) & {
+                        } & {
                             userId?: string | undefined;
                             role?: "user" | "admin" | "staff" | undefined;
                         };
@@ -1774,27 +1979,29 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
             }>;
         };
         $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">;
+            YOU_ARE_NOT_ALLOWED_TO_SET_USERS_EMAIL: import("better-auth").RawError<"YOU_ARE_NOT_ALLOWED_TO_SET_USERS_EMAIL">;
+            PASSWORD_CANNOT_BE_UPDATED_VIA_UPDATE_USER: import("better-auth").RawError<"PASSWORD_CANNOT_BE_UPDATED_VIA_UPDATE_USER">;
         };
         schema: {
             user: {
@@ -1827,85 +2034,46 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
                     impersonatedBy: {
                         type: "string";
                         required: false;
+                        input: false;
                     };
                 };
             };
         };
         options: NoInfer<{
             accessControl: {
-                newRole<K extends "user" | "session">(statements: import("better-auth/plugins").Subset<K, {
-                    readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
+                newRole<const TRoleStatements extends import("better-auth/plugins").Statements>(statements: import("better-auth/plugins").RoleInput<{
+                    readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "impersonate-admins", "delete", "set-password", "set-email", "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, {
-                        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
-                        readonly session: readonly ["list", "revoke", "delete"];
-                    }>[key] | {
-                        actions: import("better-auth/plugins").Subset<K, {
-                            readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
-                            readonly session: readonly ["list", "revoke", "delete"];
-                        }>[key];
-                        connector: "OR" | "AND";
-                    } | undefined; } : never, connector?: "OR" | "AND"): import("better-auth/plugins").AuthorizeResponse;
-                    statements: import("better-auth/plugins").Subset<K, {
-                        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
-                        readonly session: readonly ["list", "revoke", "delete"];
-                    }>;
-                };
+                }, TRoleStatements>): import("better-auth/plugins").Role<import("better-auth/plugins").ExactRoleStatements<TRoleStatements>, {
+                    readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "impersonate-admins", "delete", "set-password", "set-email", "get", "update"];
+                    readonly session: readonly ["list", "revoke", "delete"];
+                }>;
                 statements: {
-                    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", "set-email", "get", "update"];
                     readonly session: readonly ["list", "revoke", "delete"];
                 };
             };
             roles: {
-                admin: {
-                    authorize<K_1 extends "user" | "session">(request: K_1 extends infer T extends K ? { [key in T]?: import("better-auth/plugins").Subset<"user" | "session", {
-                        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
-                        readonly session: readonly ["list", "revoke", "delete"];
-                    }>[key] | {
-                        actions: import("better-auth/plugins").Subset<"user" | "session", {
-                            readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
-                            readonly session: readonly ["list", "revoke", "delete"];
-                        }>[key];
-                        connector: "OR" | "AND";
-                    } | undefined; } : never, connector?: "OR" | "AND"): import("better-auth/plugins").AuthorizeResponse;
-                    statements: import("better-auth/plugins").Subset<"user" | "session", {
-                        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
-                        readonly session: readonly ["list", "revoke", "delete"];
-                    }>;
-                };
-                user: {
-                    authorize<K_1 extends "user" | "session">(request: K_1 extends infer T extends K ? { [key in T]?: import("better-auth/plugins").Subset<"user" | "session", {
-                        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
-                        readonly session: readonly ["list", "revoke", "delete"];
-                    }>[key] | {
-                        actions: import("better-auth/plugins").Subset<"user" | "session", {
-                            readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
-                            readonly session: readonly ["list", "revoke", "delete"];
-                        }>[key];
-                        connector: "OR" | "AND";
-                    } | undefined; } : never, connector?: "OR" | "AND"): import("better-auth/plugins").AuthorizeResponse;
-                    statements: import("better-auth/plugins").Subset<"user" | "session", {
-                        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
-                        readonly session: readonly ["list", "revoke", "delete"];
-                    }>;
-                };
-                staff: {
-                    authorize<K_1 extends "user">(request: K_1 extends infer T extends K ? { [key in T]?: import("better-auth/plugins").Subset<"user", {
-                        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
-                        readonly session: readonly ["list", "revoke", "delete"];
-                    }>[key] | {
-                        actions: import("better-auth/plugins").Subset<"user", {
-                            readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
-                            readonly session: readonly ["list", "revoke", "delete"];
-                        }>[key];
-                        connector: "OR" | "AND";
-                    } | undefined; } : never, connector?: "OR" | "AND"): import("better-auth/plugins").AuthorizeResponse;
-                    statements: import("better-auth/plugins").Subset<"user", {
-                        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
-                        readonly session: readonly ["list", "revoke", "delete"];
-                    }>;
-                };
+                admin: import("better-auth/plugins").Role<import("better-auth/plugins").ExactRoleStatements<import("better-auth/plugins").ExactRoleStatements<{
+                    readonly user: ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "set-email", "get", "update"];
+                    readonly session: ["list", "revoke", "delete"];
+                }>>, {
+                    readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "impersonate-admins", "delete", "set-password", "set-email", "get", "update"];
+                    readonly session: readonly ["list", "revoke", "delete"];
+                }>;
+                user: import("better-auth/plugins").Role<import("better-auth/plugins").ExactRoleStatements<import("better-auth/plugins").ExactRoleStatements<{
+                    readonly user: [];
+                    readonly session: [];
+                }>>, {
+                    readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "impersonate-admins", "delete", "set-password", "set-email", "get", "update"];
+                    readonly session: readonly ["list", "revoke", "delete"];
+                }>;
+                staff: import("better-auth/plugins").Role<import("better-auth/plugins").ExactRoleStatements<{
+                    readonly user: ["create", "list", "delete"];
+                }>, {
+                    readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "impersonate-admins", "delete", "set-password", "set-email", "get", "update"];
+                    readonly session: readonly ["list", "revoke", "delete"];
+                }>;
             };
         }>;
     })[];
@@ -1940,8 +2108,8 @@ export declare function getBaseAuthConfig<const C extends Config>(ctx: {
         };
     };
     readonly hooks: {
-        readonly before: (inputContext: import("better-auth/*").MiddlewareInputContext<import("better-auth/*").MiddlewareOptions>) => Promise<unknown>;
-        readonly after: (inputContext: import("better-auth/*").MiddlewareInputContext<import("better-auth/*").MiddlewareOptions>) => Promise<unknown>;
+        readonly before: import("better-call").MiddlewareHandler;
+        readonly after: import("better-call").MiddlewareHandler;
     };
     readonly emailAndPassword: {
         readonly enabled: true;