rimecms 0.31.3 → 0.31.5

package/dist/core/rime.server.d.ts

@@ -14,40 +14,47 @@ export type ConfigContext<C extends Config = Config> = ReturnType<typeof createC
  */
 export declare function createRime<const C extends Config>(config: BuildConfig<C>): Promise<{
     readonly defineLocale: (event: RequestEvent) => string | undefined;
-    readonly auth: import("better-auth/*").Auth<{
+    readonly auth: import("better-auth").Auth<{
         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;
@@ -68,14 +75,10 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                             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/*").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;
@@ -84,44 +87,97 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                                 storeStateStrategy: "database" | "cookie";
                             };
                             newSession: {
-                                session: import("better-auth/*").Session & Record<string, any>;
-                                user: import("better-auth/*").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/*").Session & Record<string, any>;
-                                user: import("better-auth/*").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/*").Session & Record<string, any>;
-                                user: import("better-auth/*").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/*").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/*").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-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/*").ModelNames;
+                                model: import("better-auth").ModelNames;
                                 size?: number | undefined;
                             }) => string | false;
-                            secondaryStorage: import("better-auth/*").SecondaryStorage | undefined;
+                            secondaryStorage: import("better-auth").SecondaryStorage | undefined;
                             password: {
                                 hash: (password: string) => Promise<string>;
                                 verify: (data: {
@@ -132,9 +188,9 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                                     minPasswordLength: number;
                                     maxPasswordLength: number;
                                 };
-                                checkPassword: (userId: string, ctx: import("better-auth/*").GenericEndpointContext<import("better-auth/*").BetterAuthOptions>) => Promise<boolean>;
+                                checkPassword: (userId: string, ctx: import("better-auth").GenericEndpointContext<import("better-auth").BetterAuthOptions>) => Promise<boolean>;
                             };
-                            tables: import("better-auth/*").BetterAuthDBSchema;
+                            tables: import("better-auth").BetterAuthDBSchema;
                             runMigrations: () => Promise<void>;
                             publishTelemetry: (event: {
                                 type: string;
@@ -144,28 +200,33 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                             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;
@@ -220,7 +281,7 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                                                         nullable: boolean;
                                                         description: string;
                                                     };
-                                                    userId: {
+                                                    referenceId: {
                                                         type: string;
                                                         description: string;
                                                     };
@@ -300,10 +361,11 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                     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;
@@ -318,16 +380,17 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                     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;
@@ -342,21 +405,22 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                 } | {
                     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;
@@ -378,7 +442,7 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                                 image?: string | null | undefined;
                             };
                         };
-                    }>)[];
+                    }>>[];
                     metadata: {
                         openapi: {
                             description: string;
@@ -505,10 +569,11 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                         [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;
@@ -523,23 +588,24 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                     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;
@@ -666,10 +732,11 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                         [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;
@@ -684,12 +751,13 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                     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;
@@ -711,7 +779,7 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                                 image?: string | null | undefined;
                             };
                         };
-                    }>)[];
+                    }>>[];
                     metadata: {
                         openapi: {
                             description: string;
@@ -755,9 +823,9 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                 }, {
                     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;
@@ -779,7 +847,18 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                                 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;
@@ -789,113 +868,133 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                                     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[];
                                             };
                                         };
                                     };
@@ -904,30 +1003,36 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                         };
                     };
                 }, {
-                    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;
@@ -937,34 +1042,36 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
             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;
@@ -1049,16 +1156,16 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                             required: false;
                             input: true;
                             transform: {
-                                input(value: import("better-auth/*").DBPrimitive): string;
-                                output(value: import("better-auth/*").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: {
@@ -1097,7 +1204,7 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                                     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>;
                             };
                         };
                     };
@@ -1105,24 +1212,33 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
             };
             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/*").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;
@@ -1156,17 +1272,26 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                 }, {
                     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/*").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;
@@ -1192,15 +1317,15 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                         };
                     };
                 }, 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;
@@ -1237,18 +1362,27 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                 }, {
                     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/*").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;
@@ -1274,44 +1408,57 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                         };
                     };
                 }, 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/*").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;
@@ -1353,17 +1500,26 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                     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/*").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;
@@ -1394,17 +1550,26 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                 }, {
                     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/*").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;
@@ -1432,19 +1597,28 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                 }, {
                     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/*").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;
@@ -1472,17 +1646,26 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                 }, {
                     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/*").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;
@@ -1523,7 +1706,7 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                     };
                     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;
                 }, {
@@ -1547,17 +1730,26 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                         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/*").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;
@@ -1585,17 +1777,26 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                 }, {
                     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/*").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;
@@ -1623,17 +1824,26 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                 }, {
                     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/*").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;
@@ -1661,18 +1871,27 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                 }, {
                     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/*").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;
@@ -1700,18 +1919,16 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                 }, {
                     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;
@@ -1721,11 +1938,6 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                                         schema: {
                                             type: "object";
                                             properties: {
-                                                permission: {
-                                                    type: string;
-                                                    description: string;
-                                                    deprecated: boolean;
-                                                };
                                                 permissions: {
                                                     type: string;
                                                     description: string;
@@ -1759,19 +1971,12 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                             };
                         };
                         $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;
                             };
@@ -1783,27 +1988,29 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                 }>;
             };
             $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: {
@@ -1836,91 +2043,52 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                         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"];
+                    }>;
                 };
             }>;
         } | (C["$auth"] extends {
             plugins: any;
         } ? C["$auth"]["plugins"] : [])[number])[];
-        database: (options: import("better-auth/*").BetterAuthOptions) => import("better-auth/*").DBAdapter<import("better-auth/*").BetterAuthOptions>;
+        database: (options: import("better-auth").BetterAuthOptions) => import("better-auth").DBAdapter<import("better-auth").BetterAuthOptions>;
         baseURL: any;
         rateLimit: {
             readonly enabled: boolean;
@@ -1953,8 +2121,8 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
             };
         };
         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;
         };
         emailAndPassword: {
             readonly enabled: true;
@@ -2020,40 +2188,47 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
         actions?: infer A;
     } ? N extends string ? Record<N, NonNullable<A>> : never : never : Record<string, never>) & {
         /** The Better-auth instance */
-        readonly auth: import("better-auth/*").Auth<{
+        readonly auth: import("better-auth").Auth<{
             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;
@@ -2074,14 +2249,10 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                                 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/*").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;
@@ -2090,44 +2261,97 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                                     storeStateStrategy: "database" | "cookie";
                                 };
                                 newSession: {
-                                    session: import("better-auth/*").Session & Record<string, any>;
-                                    user: import("better-auth/*").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/*").Session & Record<string, any>;
-                                    user: import("better-auth/*").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/*").Session & Record<string, any>;
-                                    user: import("better-auth/*").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/*").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/*").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-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/*").ModelNames;
+                                    model: import("better-auth").ModelNames;
                                     size?: number | undefined;
                                 }) => string | false;
-                                secondaryStorage: import("better-auth/*").SecondaryStorage | undefined;
+                                secondaryStorage: import("better-auth").SecondaryStorage | undefined;
                                 password: {
                                     hash: (password: string) => Promise<string>;
                                     verify: (data: {
@@ -2138,9 +2362,9 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                                         minPasswordLength: number;
                                         maxPasswordLength: number;
                                     };
-                                    checkPassword: (userId: string, ctx: import("better-auth/*").GenericEndpointContext<import("better-auth/*").BetterAuthOptions>) => Promise<boolean>;
+                                    checkPassword: (userId: string, ctx: import("better-auth").GenericEndpointContext<import("better-auth").BetterAuthOptions>) => Promise<boolean>;
                                 };
-                                tables: import("better-auth/*").BetterAuthDBSchema;
+                                tables: import("better-auth").BetterAuthDBSchema;
                                 runMigrations: () => Promise<void>;
                                 publishTelemetry: (event: {
                                     type: string;
@@ -2150,28 +2374,33 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                                 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;
@@ -2226,7 +2455,7 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                                                             nullable: boolean;
                                                             description: string;
                                                         };
-                                                        userId: {
+                                                        referenceId: {
                                                             type: string;
                                                             description: string;
                                                         };
@@ -2306,10 +2535,11 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                         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;
@@ -2324,16 +2554,17 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                         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;
@@ -2348,21 +2579,22 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                     } | {
                         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;
@@ -2384,7 +2616,7 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                                     image?: string | null | undefined;
                                 };
                             };
-                        }>)[];
+                        }>>[];
                         metadata: {
                             openapi: {
                                 description: string;
@@ -2511,10 +2743,11 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                             [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;
@@ -2529,23 +2762,24 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                         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;
@@ -2672,10 +2906,11 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                             [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;
@@ -2690,12 +2925,13 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                         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;
@@ -2717,7 +2953,7 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                                     image?: string | null | undefined;
                                 };
                             };
-                        }>)[];
+                        }>>[];
                         metadata: {
                             openapi: {
                                 description: string;
@@ -2761,9 +2997,9 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                     }, {
                         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;
@@ -2785,7 +3021,18 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                                     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;
@@ -2795,113 +3042,133 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                                         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[];
                                                 };
                                             };
                                         };
@@ -2910,30 +3177,36 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                             };
                         };
                     }, {
-                        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;
@@ -2943,34 +3216,36 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                 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;
@@ -3055,16 +3330,16 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                                 required: false;
                                 input: true;
                                 transform: {
-                                    input(value: import("better-auth/*").DBPrimitive): string;
-                                    output(value: import("better-auth/*").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: {
@@ -3103,7 +3378,7 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                                         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>;
                                 };
                             };
                         };
@@ -3111,24 +3386,33 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                 };
                 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/*").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;
@@ -3162,17 +3446,26 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                     }, {
                         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/*").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;
@@ -3198,15 +3491,15 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                             };
                         };
                     }, 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;
@@ -3243,18 +3536,27 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                     }, {
                         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/*").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;
@@ -3280,44 +3582,57 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                             };
                         };
                     }, 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/*").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;
@@ -3359,17 +3674,26 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                         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/*").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;
@@ -3400,17 +3724,26 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                     }, {
                         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/*").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;
@@ -3438,19 +3771,28 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                     }, {
                         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/*").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;
@@ -3478,17 +3820,26 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                     }, {
                         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/*").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;
@@ -3529,7 +3880,7 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                         };
                         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;
                     }, {
@@ -3553,17 +3904,26 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                             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/*").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;
@@ -3591,17 +3951,26 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                     }, {
                         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/*").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;
@@ -3629,17 +3998,26 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                     }, {
                         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/*").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;
@@ -3667,18 +4045,27 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                     }, {
                         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/*").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;
@@ -3706,18 +4093,16 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                     }, {
                         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;
@@ -3727,11 +4112,6 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                                             schema: {
                                                 type: "object";
                                                 properties: {
-                                                    permission: {
-                                                        type: string;
-                                                        description: string;
-                                                        deprecated: boolean;
-                                                    };
                                                     permissions: {
                                                         type: string;
                                                         description: string;
@@ -3765,19 +4145,12 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                                 };
                             };
                             $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;
                                 };
@@ -3789,27 +4162,29 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                     }>;
                 };
                 $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: {
@@ -3842,91 +4217,52 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                             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"];
+                        }>;
                     };
                 }>;
             } | (C["$auth"] extends {
                 plugins: any;
             } ? C["$auth"]["plugins"] : [])[number])[];
-            database: (options: import("better-auth/*").BetterAuthOptions) => import("better-auth/*").DBAdapter<import("better-auth/*").BetterAuthOptions>;
+            database: (options: import("better-auth").BetterAuthOptions) => import("better-auth").DBAdapter<import("better-auth").BetterAuthOptions>;
             baseURL: any;
             rateLimit: {
                 readonly enabled: boolean;
@@ -3959,8 +4295,8 @@ export declare function createRime<const C extends Config>(config: BuildConfig<C
                 };
             };
             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;
             };
             emailAndPassword: {
                 readonly enabled: true;