@onmax/nuxt-better-auth 0.0.2-alpha.21 → 0.0.2-alpha.23

package/dist/runtime/app/composables/useUserSession.d.ts

@@ -17,6 +17,6 @@ export interface UseUserSessionReturn {
         headers?: HeadersInit;
         force?: boolean;
     }) => Promise<void>;
-    updateUser: (updates: Partial<AuthUser>) => void;
+    updateUser: (updates: Partial<AuthUser>) => Promise<void>;
 }
 export declare function useUserSession(): UseUserSessionReturn;

package/dist/runtime/app/composables/useUserSession.js

@@ -1,29 +1,89 @@
 import createAppAuthClient from "#auth/client";
-import { computed, nextTick, useRequestHeaders, useRequestURL, useRuntimeConfig, useState, watch } from "#imports";
+import { computed, nextTick, useNuxtApp, useRequestHeaders, useRequestURL, useRuntimeConfig, useState, watch } from "#imports";
+let _sessionSignalListenerBound = false;
 let _client = null;
 function getClient(baseURL) {
   if (!_client)
     _client = createAppAuthClient(baseURL);
   return _client;
 }
+function getRuntimeFlags() {
+  const globalFlags = globalThis.__NUXT_BETTER_AUTH_TEST_FLAGS__;
+  if (globalFlags)
+    return globalFlags;
+  return { client: Boolean(import.meta.client), server: Boolean(import.meta.server) };
+}
+function ensureSessionSignalListener(client, onSignal) {
+  if (_sessionSignalListenerBound)
+    return;
+  const store = client.$store;
+  if (!store?.listen)
+    return;
+  _sessionSignalListenerBound = true;
+  store.listen("$sessionSignal", async () => {
+    try {
+      await onSignal();
+    } catch {
+    }
+  });
+}
 export function useUserSession() {
+  const runtimeFlags = getRuntimeFlags();
   const runtimeConfig = useRuntimeConfig();
   const requestURL = useRequestURL();
-  const client = import.meta.client ? getClient(runtimeConfig.public.siteUrl || requestURL.origin) : null;
+  const client = runtimeFlags.client ? getClient(runtimeConfig.public.siteUrl || requestURL.origin) : null;
   const session = useState("auth:session", () => null);
   const user = useState("auth:user", () => null);
   const authReady = useState("auth:ready", () => false);
   const ready = computed(() => authReady.value);
   const loggedIn = computed(() => Boolean(session.value && user.value));
+  const nuxtApp = useNuxtApp();
+  const skipHydratedSsrGetSession = computed(() => {
+    const authConfig = runtimeConfig.public.auth;
+    return Boolean(authConfig?.session?.skipHydratedSsrGetSession);
+  });
+  const shouldSkipInitialClientSessionFetch = computed(() => {
+    if (!skipHydratedSsrGetSession.value)
+      return false;
+    if (!runtimeFlags.client)
+      return false;
+    if (!nuxtApp.payload.serverRendered)
+      return false;
+    if (nuxtApp.payload.prerenderedAt || nuxtApp.payload.isCached)
+      return false;
+    return Boolean(session.value && user.value);
+  });
+  if (shouldSkipInitialClientSessionFetch.value && !authReady.value)
+    authReady.value = true;
   function clearSession() {
     session.value = null;
     user.value = null;
   }
-  function updateUser(updates) {
-    if (user.value)
-      user.value = { ...user.value, ...updates };
+  async function updateUser(updates) {
+    if (!user.value)
+      return;
+    const previousUser = user.value;
+    user.value = { ...user.value, ...updates };
+    if (!client)
+      return;
+    try {
+      const clientWithUpdateUser = client;
+      const result = await clientWithUpdateUser.updateUser(updates);
+      if (result?.error) {
+        if (typeof result.error === "string")
+          throw new Error(result.error);
+        if (result.error instanceof Error)
+          throw result.error;
+        if (typeof result.error === "object" && result.error && "message" in result.error && typeof result.error.message === "string")
+          throw new Error(result.error.message);
+        throw new Error("Failed to update user");
+      }
+    } catch (error) {
+      user.value = previousUser;
+      throw error;
+    }
   }
-  if (import.meta.client && client) {
+  if (runtimeFlags.client && client && !shouldSkipInitialClientSessionFetch.value) {
     const clientSession = client.useSession();
     watch(
       () => clientSession.value,
@@ -107,7 +167,7 @@ export function useUserSession() {
     }
   });
   async function fetchSession(options = {}) {
-    if (import.meta.server) {
+    if (runtimeFlags.server) {
       if (!authReady.value)
         authReady.value = true;
       return;
@@ -135,6 +195,9 @@ export function useUserSession() {
       }
     }
   }
+  if (runtimeFlags.client && client && shouldSkipInitialClientSessionFetch.value) {
+    ensureSessionSignalListener(client, () => fetchSession({ force: true }));
+  }
   async function signOut(options) {
     if (!client)
       throw new Error("signOut can only be called on client-side");

package/dist/runtime/app/pages/__better-auth-devtools.vue

@@ -380,8 +380,8 @@ function getAccountActions(row) {
                   <span class="config-label">Guest</span><span class="font-mono">{{ configData.config.module?.redirects?.guest }}</span>
                 </div>
                 <div class="config-row">
-                  <span class="config-label">DB</span><UBadge :color="configData.config.module?.useDatabase ? 'success' : 'neutral'" variant="subtle" size="sm">
-                    {{ configData.config.module?.useDatabase ? "Hub" : "Off" }}
+                  <span class="config-label">DB</span><UBadge :color="configData.config.module?.databaseProvider === 'none' ? 'neutral' : 'success'" variant="subtle" size="sm">
+                    {{ configData.config.module?.databaseProvider === "nuxthub" ? "Hub" : configData.config.module?.databaseProvider === "convex" ? "Convex" : "Off" }}
                   </UBadge>
                 </div>
                 <div class="config-row">

package/dist/runtime/config.d.ts

@@ -1,4 +1,4 @@
-import type { BetterAuthOptions } from 'better-auth';
+import type { BetterAuthOptions, BetterAuthPlugin } from 'better-auth';
 import type { BetterAuthClientOptions } from 'better-auth/client';
 import type { CasingOption } from '../schema-generator.js';
 import type { ServerAuthContext } from './types/augment.js';
@@ -7,12 +7,17 @@ export type { ServerAuthContext };
 export interface ClientAuthContext {
     siteUrl: string;
 }
-export type ServerAuthConfig = Omit<BetterAuthOptions, 'database' | 'secret' | 'baseURL'>;
+export type ServerAuthConfig = Omit<BetterAuthOptions, 'secret' | 'baseURL'> & {
+    plugins?: readonly BetterAuthPlugin[];
+};
 export type ClientAuthConfig = Omit<BetterAuthClientOptions, 'baseURL'> & {
     baseURL?: string;
 };
 export type ServerAuthConfigFn = (ctx: ServerAuthContext) => ServerAuthConfig;
 export type ClientAuthConfigFn = (ctx: ClientAuthContext) => ClientAuthConfig;
+export type ModuleDatabaseProviderId = 'none' | 'nuxthub' | (string & {});
+export type EffectiveDatabaseProviderId = 'user' | ModuleDatabaseProviderId;
+export type DatabaseSource = 'module' | 'user';
 export interface BetterAuthModuleOptions {
     /** Client-only mode - skip server setup for external auth backends */
     clientOnly?: boolean;
@@ -24,6 +29,16 @@ export interface BetterAuthModuleOptions {
         login?: string;
         guest?: string;
     };
+    session?: {
+        /**
+         * When enabled, and session/user are already hydrated from SSR, skip the initial
+         * client `/api/auth/get-session` bootstrap request. This also skips Better Auth's
+         * session refresh manager on those pages.
+         *
+         * Default: false
+         */
+        skipHydratedSsrGetSession?: boolean;
+    };
     /** Enable KV secondary storage for sessions. Requires hub.kv: true */
     secondaryStorage?: boolean;
     /** Schema generation options. Must match drizzleAdapter config. */
@@ -40,10 +55,16 @@ export interface AuthRuntimeConfig {
         guest: string;
     };
     useDatabase: boolean;
+    databaseProvider: EffectiveDatabaseProviderId;
+    databaseSource: DatabaseSource;
     clientOnly: boolean;
+    session: {
+        skipHydratedSsrGetSession: boolean;
+    };
 }
 export interface AuthPrivateRuntimeConfig {
     secondaryStorage: boolean;
 }
-export declare function defineServerAuth<T extends ServerAuthConfig>(config: T | ((ctx: ServerAuthContext) => T)): (ctx: ServerAuthContext) => T;
+export declare function defineServerAuth<const R extends ServerAuthConfig>(config: R): (ctx: ServerAuthContext) => R;
+export declare function defineServerAuth<const R extends ServerAuthConfig>(config: (ctx: ServerAuthContext) => R): (ctx: ServerAuthContext) => R;
 export declare function defineClientAuth<T extends ClientAuthConfig>(config: T | ((ctx: ClientAuthContext) => T)): (baseURL: string) => ReturnType<typeof createAuthClient<T>>;

package/dist/runtime/server/api/_better-auth/config.get.d.ts

@@ -7,6 +7,7 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
             };
             secondaryStorage: boolean;
             useDatabase: boolean;
+            databaseProvider: "none" | "nuxthub" | "convex";
         };
         server: {
             baseURL: any;
@@ -14,6 +15,7 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
             socialProviders: string[];
             plugins: any;
             trustedOrigins: any;
+            configuredTrustedOrigins: any;
             session: {
                 expiresIn: string;
                 updateAge: string;

package/dist/runtime/server/api/_better-auth/config.get.js

@@ -5,9 +5,12 @@ export default defineEventHandler(async (event) => {
   try {
     const auth = serverAuth(event);
     const options = auth.options;
+    const authContext = await auth.$context;
     const runtimeConfig = useRuntimeConfig();
     const publicAuth = runtimeConfig.public?.auth;
     const privateAuth = runtimeConfig.auth;
+    const configuredTrustedOrigins = Array.isArray(options.trustedOrigins) ? options.trustedOrigins : [];
+    const effectiveTrustedOrigins = authContext?.trustedOrigins || configuredTrustedOrigins;
     const sessionConfig = options.session || {};
     const expiresInDays = sessionConfig.expiresIn ? Math.round(sessionConfig.expiresIn / 86400) : 7;
     const updateAgeDays = sessionConfig.updateAge ? Math.round(sessionConfig.updateAge / 86400) : 1;
@@ -17,7 +20,8 @@ export default defineEventHandler(async (event) => {
         module: {
           redirects: publicAuth?.redirects || { login: "/login", guest: "/" },
           secondaryStorage: privateAuth?.secondaryStorage ?? false,
-          useDatabase: publicAuth?.useDatabase ?? false
+          useDatabase: publicAuth?.useDatabase ?? false,
+          databaseProvider: publicAuth?.databaseProvider ?? "none"
         },
         // Server config (server/auth.config.ts)
         server: {
@@ -25,7 +29,8 @@ export default defineEventHandler(async (event) => {
           basePath: options.basePath || "/api/auth",
           socialProviders: Object.keys(options.socialProviders || {}),
           plugins: (options.plugins || []).map((p) => p.id || "unknown"),
-          trustedOrigins: options.trustedOrigins || [],
+          trustedOrigins: effectiveTrustedOrigins,
+          configuredTrustedOrigins,
           session: {
             expiresIn: `${expiresInDays} days`,
             updateAge: `${updateAgeDays} days`,

package/dist/runtime/server/utils/auth.d.ts

@@ -2,6 +2,6 @@ import type { Auth } from 'better-auth';
 import type { H3Event } from 'h3';
 import createServerAuth from '#auth/server';
 type AuthInstance = Auth<ReturnType<typeof createServerAuth>>;
-/** Returns Better Auth instance. Pass event for accurate URL detection on first call. */
+/** Returns Better Auth instance. Caches per resolved host (or single instance when siteUrl is explicit). */
 export declare function serverAuth(event?: H3Event): AuthInstance;
 export {};

package/dist/runtime/server/utils/auth.js

@@ -5,15 +5,53 @@ import { betterAuth } from "better-auth";
 import { getRequestHost, getRequestProtocol } from "h3";
 import { useRuntimeConfig } from "nitropack/runtime";
 import { withoutProtocol } from "ufo";
-let _auth = null;
+const _authCache = /* @__PURE__ */ new Map();
+let _baseURLInferenceLogged = false;
+function normalizeLoopbackOrigin(origin) {
+  if (!import.meta.dev)
+    return origin;
+  try {
+    const url = new URL(origin);
+    if (url.hostname === "127.0.0.1" || url.hostname === "::1" || url.hostname === "[::1]") {
+      url.hostname = "localhost";
+      return url.origin;
+    }
+  } catch {
+  }
+  return origin;
+}
+function logInferredBaseURL(baseURL, source) {
+  if (!import.meta.dev || _baseURLInferenceLogged)
+    return;
+  _baseURLInferenceLogged = true;
+  console.warn(`[nuxt-better-auth] Using inferred baseURL "${baseURL}" from ${source}. Set runtimeConfig.public.siteUrl for deterministic OAuth callbacks.`);
+}
 function validateURL(url) {
   try {
-    return new URL(url).origin;
+    return normalizeLoopbackOrigin(new URL(url).origin);
   } catch {
     throw new Error(`Invalid siteUrl: "${url}". Must be a valid URL.`);
   }
 }
-function getNitroOrigin(e) {
+function resolveConfiguredSiteUrl(config) {
+  if (typeof config.public.siteUrl !== "string" || !config.public.siteUrl)
+    return void 0;
+  return validateURL(config.public.siteUrl);
+}
+function resolveEventOrigin(event) {
+  if (!event)
+    return void 0;
+  const host = getRequestHost(event, { xForwardedHost: true });
+  const protocol = getRequestProtocol(event, { xForwardedProto: true });
+  if (!host || !protocol)
+    return void 0;
+  try {
+    return validateURL(`${protocol}://${host}`);
+  } catch {
+    return void 0;
+  }
+}
+function getNitroOrigin() {
   const cert = process.env.NITRO_SSL_CERT;
   const key = process.env.NITRO_SSL_KEY;
   let host = process.env.NITRO_HOST || process.env.HOST;
@@ -30,15 +68,18 @@ function getNitroOrigin(e) {
       const origin = JSON.parse(process.env.NUXT_VITE_NODE_OPTIONS).baseURL.replace("/__nuxt_vite_node__", "");
       host = withoutProtocol(origin);
       protocol = origin.includes("https") ? "https" : "http";
-    } else if (e) {
-      host = getRequestHost(e, { xForwardedHost: true }) || host;
-      protocol = getRequestProtocol(e, { xForwardedProto: true }) || protocol;
     }
   } catch {
   }
   if (!host)
     return void 0;
-  if (host.includes(":") && !host.startsWith("[")) {
+  if (host.startsWith("[") && host.includes("]:")) {
+    const lastBracketColon = host.lastIndexOf("]:");
+    const extractedPort = host.slice(lastBracketColon + 2);
+    host = host.slice(0, lastBracketColon + 1);
+    if (extractedPort)
+      port = extractedPort;
+  } else if (host.includes(":") && !host.startsWith("[")) {
     const hostParts = host.split(":");
     port = hostParts.pop();
     host = hostParts.join(":");
@@ -46,36 +87,116 @@ function getNitroOrigin(e) {
   const portSuffix = port ? `:${port}` : "";
   return `${protocol}://${host}${portSuffix}`;
 }
-function getBaseURL(event) {
-  const config = useRuntimeConfig();
-  if (config.public.siteUrl && typeof config.public.siteUrl === "string")
-    return validateURL(config.public.siteUrl);
-  const nitroOrigin = getNitroOrigin(event);
+function resolveEnvironmentOrigin() {
+  const nitroOrigin = getNitroOrigin();
   if (nitroOrigin)
-    return validateURL(nitroOrigin);
+    return { origin: validateURL(nitroOrigin), source: "Nitro environment detection" };
   if (process.env.VERCEL_URL)
-    return validateURL(`https://${process.env.VERCEL_URL}`);
+    return { origin: validateURL(`https://${process.env.VERCEL_URL}`), source: "VERCEL_URL" };
   if (process.env.CF_PAGES_URL)
-    return validateURL(`https://${process.env.CF_PAGES_URL}`);
+    return { origin: validateURL(`https://${process.env.CF_PAGES_URL}`), source: "CF_PAGES_URL" };
   if (process.env.URL)
-    return validateURL(process.env.URL.startsWith("http") ? process.env.URL : `https://${process.env.URL}`);
-  if (import.meta.dev)
-    return "http://localhost:3000";
+    return { origin: validateURL(process.env.URL.startsWith("http") ? process.env.URL : `https://${process.env.URL}`), source: "URL" };
+  return void 0;
+}
+function resolveDevFallback() {
+  if (!import.meta.dev)
+    return void 0;
+  return { origin: "http://localhost:3000", source: "development fallback" };
+}
+function getBaseURL(event) {
+  const config = useRuntimeConfig();
+  const configuredSiteUrl = resolveConfiguredSiteUrl(config);
+  if (configuredSiteUrl)
+    return configuredSiteUrl;
+  const eventOrigin = resolveEventOrigin(event);
+  if (eventOrigin) {
+    logInferredBaseURL(eventOrigin, "request origin");
+    return eventOrigin;
+  }
+  const environmentOrigin = resolveEnvironmentOrigin();
+  if (environmentOrigin) {
+    logInferredBaseURL(environmentOrigin.origin, environmentOrigin.source);
+    return environmentOrigin.origin;
+  }
+  const devFallback = resolveDevFallback();
+  if (devFallback) {
+    logInferredBaseURL(devFallback.origin, devFallback.source);
+    return devFallback.origin;
+  }
   throw new Error("siteUrl required. Set NUXT_PUBLIC_SITE_URL.");
 }
+function dedupeOrigins(origins) {
+  return [...new Set(origins)];
+}
+function getDevTrustedOrigins() {
+  const fallbackOrigin = "http://localhost:3000";
+  const nitroOrigin = getNitroOrigin();
+  if (!nitroOrigin)
+    return [fallbackOrigin];
+  try {
+    const url = new URL(nitroOrigin);
+    const protocol = url.protocol === "https:" ? "https" : "http";
+    const port = url.port || "3000";
+    const localhostOrigin = `${protocol}://localhost:${port}`;
+    return dedupeOrigins([localhostOrigin, url.origin]);
+  } catch {
+    return [fallbackOrigin];
+  }
+}
+function getRequestOrigin(request) {
+  if (!request)
+    return void 0;
+  try {
+    return new URL(request.url).origin;
+  } catch {
+    return void 0;
+  }
+}
+function withDevTrustedOrigins(trustedOrigins, hasExplicitSiteUrl) {
+  if (!import.meta.dev || !hasExplicitSiteUrl)
+    return trustedOrigins;
+  const devOrigins = getDevTrustedOrigins();
+  const mergeOrigins = (origins, request) => {
+    const validOrigins = origins.filter((origin) => typeof origin === "string");
+    const requestOrigin = getRequestOrigin(request);
+    return dedupeOrigins(requestOrigin ? [...validOrigins, ...devOrigins, requestOrigin] : [...validOrigins, ...devOrigins]);
+  };
+  if (typeof trustedOrigins === "function") {
+    return async (request) => {
+      const resolvedOrigins = await trustedOrigins(request);
+      return mergeOrigins(resolvedOrigins, request);
+    };
+  }
+  if (Array.isArray(trustedOrigins)) {
+    const baseOrigins = mergeOrigins(trustedOrigins);
+    return async (request) => {
+      return mergeOrigins(baseOrigins, request);
+    };
+  }
+  return async (request) => {
+    return mergeOrigins([], request);
+  };
+}
 export function serverAuth(event) {
-  if (_auth)
-    return _auth;
   const runtimeConfig = useRuntimeConfig();
   const siteUrl = getBaseURL(event);
+  const hasExplicitSiteUrl = runtimeConfig.public.siteUrl && typeof runtimeConfig.public.siteUrl === "string";
+  const cacheKey = hasExplicitSiteUrl ? "__explicit__" : siteUrl;
+  const cached = _authCache.get(cacheKey);
+  if (cached)
+    return cached;
   const database = createDatabase();
   const userConfig = createServerAuth({ runtimeConfig, db });
-  _auth = betterAuth({
+  const trustedOrigins = withDevTrustedOrigins(userConfig.trustedOrigins, Boolean(hasExplicitSiteUrl));
+  const auth = betterAuth({
     ...userConfig,
     ...database && { database },
     secondaryStorage: createSecondaryStorage(),
     secret: runtimeConfig.betterAuthSecret,
-    baseURL: siteUrl
+    baseURL: siteUrl,
+    trustedOrigins
   });
-  return _auth;
+  _authCache.set(cacheKey, auth);
+  return auth;
 }

package/dist/runtime/server/utils/session.d.ts

@@ -1,9 +1,17 @@
+import type { AuthSession, AuthUser } from '#nuxt-better-auth';
 import type { H3Event } from 'h3';
-import type { AuthSession, AuthUser, RequireSessionOptions } from '../../types.js';
+import type { UserMatch } from '../../types.js';
 interface FullSession {
     user: AuthUser;
     session: AuthSession;
 }
+interface RequireUserSessionOptions {
+    user?: UserMatch<AuthUser>;
+    rule?: (ctx: {
+        user: AuthUser;
+        session: AuthSession;
+    }) => boolean | Promise<boolean>;
+}
 export declare function getUserSession(event: H3Event): Promise<FullSession | null>;
-export declare function requireUserSession(event: H3Event, options?: RequireSessionOptions): Promise<FullSession>;
+export declare function requireUserSession(event: H3Event, options?: RequireUserSessionOptions): Promise<FullSession>;
 export {};

package/dist/runtime/types/augment.d.ts

@@ -38,5 +38,5 @@ export interface UserSessionComposable {
     signOut: (options?: {
         onSuccess?: () => void | Promise<void>;
     }) => Promise<void>;
-    updateUser: (updates: Partial<AuthUser>) => void;
+    updateUser: (updates: Partial<AuthUser>) => Promise<void>;
 }

package/dist/runtime/types.d.ts

@@ -1,7 +1,7 @@
 import type { NitroRouteRules } from 'nitropack/types';
 import type { AuthSession, AuthUser } from './types/augment.js';
 export type { AuthSession, AuthUser, ServerAuthContext, UserSessionComposable } from './types/augment.js';
-export type { Auth, InferPluginTypes, InferSession, InferUser } from 'better-auth';
+export type { Auth, InferPluginTypes, InferSessionFromClient as InferSession, InferUserFromClient as InferUser } from 'better-auth';
 export type AuthMode = 'guest' | 'user';
 export type UserMatch<T> = {
     [K in keyof T]?: T[K] | T[K][];

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@onmax/nuxt-better-auth",
   "type": "module",
-  "version": "0.0.2-alpha.21",
+  "version": "0.0.2-alpha.23",
   "packageManager": "pnpm@10.15.1",
   "description": "Nuxt module for Better Auth integration with NuxtHub, route protection, session management, and role-based access",
   "author": "onmax",
   "license": "MIT",
+  "homepage": "https://better-auth.nuxt.dev",
   "repository": {
     "type": "git",
     "url": "https://github.com/nuxt-modules/better-auth"
@@ -26,10 +27,6 @@
     "./config": {
       "types": "./dist/runtime/config.d.ts",
       "import": "./dist/runtime/config.js"
-    },
-    "./adapters/convex": {
-      "types": "./dist/runtime/adapters/convex.d.ts",
-      "import": "./dist/runtime/adapters/convex.js"
     }
   },
   "main": "./dist/module.mjs",
@@ -40,9 +37,6 @@
       ],
       "config": [
         "./dist/runtime/config.d.ts"
-      ],
-      "adapters/convex": [
-        "./dist/runtime/adapters/convex.d.ts"
       ]
     }
   },
@@ -67,15 +61,11 @@
   },
   "peerDependencies": {
     "@nuxthub/core": ">=0.10.5",
-    "better-auth": ">=1.0.0",
-    "convex": ">=1.25.0"
+    "better-auth": ">=1.0.0"
   },
   "peerDependenciesMeta": {
     "@nuxthub/core": {
       "optional": true
-    },
-    "convex": {
-      "optional": true
     }
   },
   "dependencies": {

package/dist/runtime/adapters/convex.d.ts

@@ -1,111 +0,0 @@
-import type { FunctionReference } from 'convex/server';
-interface ConvexCleanedWhere {
-    field: string;
-    value: string | number | boolean | string[] | number[] | null;
-    operator?: 'lt' | 'lte' | 'gt' | 'gte' | 'eq' | 'in' | 'not_in' | 'ne' | 'contains' | 'starts_with' | 'ends_with';
-    connector?: 'AND' | 'OR';
-}
-interface PaginationResult<T> {
-    page: T[];
-    isDone: boolean;
-    continueCursor: string | null;
-    splitCursor?: string;
-    pageStatus?: 'SplitRecommended' | 'SplitRequired' | string;
-    count?: number;
-}
-interface ConvexAuthApi {
-    create: FunctionReference<'mutation', 'public', {
-        input: {
-            model: string;
-            data: Record<string, unknown>;
-        };
-        select?: string[];
-    }, unknown>;
-    findOne: FunctionReference<'query', 'public', {
-        model: string;
-        where?: ConvexCleanedWhere[];
-        select?: string[];
-    }, unknown>;
-    findMany: FunctionReference<'query', 'public', {
-        model: string;
-        where?: ConvexCleanedWhere[];
-        limit?: number;
-        sortBy?: {
-            direction: 'asc' | 'desc';
-            field: string;
-        };
-        paginationOpts: {
-            numItems: number;
-            cursor: string | null;
-        };
-    }, PaginationResult<unknown>>;
-    updateOne: FunctionReference<'mutation', 'public', {
-        input: {
-            model: string;
-            where?: ConvexCleanedWhere[];
-            update: Record<string, unknown>;
-        };
-    }, unknown>;
-    updateMany: FunctionReference<'mutation', 'public', {
-        input: {
-            model: string;
-            where?: ConvexCleanedWhere[];
-            update: Record<string, unknown>;
-        };
-        paginationOpts: {
-            numItems: number;
-            cursor: string | null;
-        };
-    }, PaginationResult<unknown> & {
-        count: number;
-    }>;
-    deleteOne: FunctionReference<'mutation', 'public', {
-        input: {
-            model: string;
-            where?: ConvexCleanedWhere[];
-        };
-    }, unknown>;
-    deleteMany: FunctionReference<'mutation', 'public', {
-        input: {
-            model: string;
-            where?: ConvexCleanedWhere[];
-        };
-        paginationOpts: {
-            numItems: number;
-            cursor: string | null;
-        };
-    }, PaginationResult<unknown> & {
-        count: number;
-    }>;
-}
-export interface ConvexHttpAdapterOptions {
-    /** Convex deployment URL (e.g., https://your-app.convex.cloud) */
-    url: string;
-    /** Convex API functions for auth operations - import from your convex/_generated/api */
-    api: ConvexAuthApi;
-    /** Enable debug logging for adapter operations */
-    debugLogs?: boolean;
-}
-/**
- * Creates a Better Auth adapter that communicates with Convex via HTTP.
- * Uses ConvexHttpClient for server-side auth operations.
- *
- * @example
- * ```ts
- * import { api } from '~/convex/_generated/api'
- *
- * export default defineServerAuth(() => ({
- *   database: createConvexHttpAdapter({
- *     url: process.env.CONVEX_URL!,
- *     api: api.auth,
- *   }),
- * }))
- * ```
- *
- * @limitations
- * - `update()` only supports AND-connected where clauses (no OR support)
- * - `count()` fetches all documents client-side (Convex limitation)
- * - `offset` pagination not supported in `findMany()`
- */
-export declare function createConvexHttpAdapter(options: ConvexHttpAdapterOptions): import("better-auth/adapters").AdapterFactory;
-export {};