use-convex 0.0.2

package/dist/runtime/composables/useAuthToken.js

@@ -0,0 +1,71 @@
+import { navigateTo } from "nuxt/app";
+import {
+  computed,
+  ref,
+  watch
+} from "vue";
+import { useConvexAuth } from "./useConvexAuth.js";
+import { tryUseConvexContext } from "../utils/context.js";
+export function useAuthToken() {
+  const token = ref(null);
+  const ctx = tryUseConvexContext();
+  if (!ctx) {
+    return computed(() => null);
+  }
+  const auth = useConvexAuth();
+  const refresh = async () => {
+    if (!ctx.client) {
+      token.value = null;
+      return;
+    }
+    try {
+      const claims = ctx.client.getAuth();
+      if (claims?.token) {
+        token.value = claims.token;
+        return;
+      }
+    } catch {
+    }
+    if (!auth.isAuthenticated.value) {
+      token.value = null;
+      return;
+    }
+    const fetchToken = ctx.auth.fetchToken;
+    if (!fetchToken) {
+      token.value = null;
+      return;
+    }
+    try {
+      token.value = await fetchToken({ forceRefreshToken: false }) ?? null;
+    } catch {
+      token.value = null;
+    }
+  };
+  watch(
+    [
+      () => auth.isAuthenticated.value,
+      () => auth.isRefreshing.value,
+      () => auth.isLoading.value
+    ],
+    () => {
+      void refresh();
+    },
+    { immediate: true }
+  );
+  return computed(() => token.value);
+}
+export function requireConvexAuthMiddleware(options = {}) {
+  const redirectTo = options.redirectTo ?? "/login";
+  const ctx = tryUseConvexContext();
+  if (!ctx) {
+    return navigateTo(redirectTo);
+  }
+  const auth = useConvexAuth();
+  if (auth.showAuthedUi.value) {
+    return;
+  }
+  if (auth.isLoading.value) {
+    return;
+  }
+  return navigateTo(redirectTo);
+}

package/dist/runtime/composables/useConvex.d.ts

@@ -0,0 +1,5 @@
+import type { ConvexClient } from 'convex/browser';
+/**
+ * Returns the browser ConvexClient. Throws if called during SSR.
+ */
+export declare function useConvex(): ConvexClient;

package/dist/runtime/composables/useConvex.js

@@ -0,0 +1,10 @@
+import { useConvexContext } from "../utils/context.js";
+export function useConvex() {
+  const ctx = useConvexContext();
+  if (!ctx.client) {
+    throw new Error(
+      "[convex-nuxt] useConvex() is only available in the browser. Use fetchQuery on the server."
+    );
+  }
+  return ctx.client;
+}

package/dist/runtime/composables/useConvexAction.d.ts

@@ -0,0 +1,13 @@
+import type { FunctionArgs, FunctionReference, FunctionReturnType } from 'convex/server';
+import { type MaybeRefOrGetter } from 'vue';
+/**
+ * Browser action helper. Returns `{ run, error, pending }`.
+ *
+ * Safe to call during SSR setup — the ConvexClient is only touched when
+ * `run()` runs in the browser.
+ */
+export declare function useConvexAction<Action extends FunctionReference<'action'>>(action: Action): {
+    run: (args?: MaybeRefOrGetter<FunctionArgs<Action>>) => Promise<FunctionReturnType<Action>>;
+    error: import("vue").Ref<Error | null, Error | null>;
+    pending: import("vue").ComputedRef<boolean>;
+};

package/dist/runtime/composables/useConvexAction.js

@@ -0,0 +1,30 @@
+import { computed, ref, toValue } from "vue";
+import { useConvexContext } from "../utils/context.js";
+export function useConvexAction(action) {
+  const ctx = useConvexContext();
+  const error = ref(null);
+  const pendingCount = ref(0);
+  const run = async (args = {}) => {
+    if (import.meta.server || !ctx.client) {
+      throw new Error(
+        "[convex-nuxt] useConvexAction can only run in the browser."
+      );
+    }
+    pendingCount.value++;
+    error.value = null;
+    try {
+      return await ctx.client.action(action, toValue(args));
+    } catch (cause) {
+      const err = cause instanceof Error ? cause : new Error(String(cause));
+      error.value = err;
+      throw err;
+    } finally {
+      pendingCount.value--;
+    }
+  };
+  return {
+    run,
+    error,
+    pending: computed(() => pendingCount.value > 0)
+  };
+}

package/dist/runtime/composables/useConvexAuth.d.ts

@@ -0,0 +1,51 @@
+import type { AuthTokenFetcher } from 'convex/browser';
+import { type ComputedRef, type MaybeRefOrGetter } from 'vue';
+export type { AuthTokenFetcher };
+export interface UseConvexAuthSetupOptions {
+    /**
+     * Async function returning a JWT (or null). Called by ConvexClient when
+     * the current token expires or is rejected. Pass `{ forceRefreshToken: true }`
+     * when a fresh token is required.
+     */
+    fetchToken: AuthTokenFetcher;
+    /**
+     * Auth provider is still resolving its initial session.
+     * @default false
+     */
+    isLoading?: MaybeRefOrGetter<boolean>;
+    /**
+     * Auth provider believes a user is signed in (has a session / tokens).
+     * Defaults to `true` so a bare `fetchToken` is enough for simple demos —
+     * Convex confirmation still gates `isAuthenticated`.
+     * @default true
+     */
+    isAuthenticated?: MaybeRefOrGetter<boolean>;
+}
+export interface UseConvexAuthReturn {
+    isLoading: ComputedRef<boolean>;
+    isAuthenticated: ComputedRef<boolean>;
+    isRefreshing: ComputedRef<boolean>;
+    /**
+     * JWT cookie is present. Use with `isAuthenticated` to keep an SSR-gated
+     * shell mounted while Convex confirms — do not live-subscribe on this alone.
+     */
+    hasSsrSession: ComputedRef<boolean>;
+    /**
+     * Mount the signed-in shell when the SSR cookie is present **or** Convex
+     * has confirmed auth. Prefer this over `isAuthenticated` alone so SSR HTML
+     * does not flash the signed-out gate during client confirmation.
+     *
+     * Live subscriptions must still gate on `isAuthenticated` (use `'skip'`).
+     */
+    showAuthedUi: ComputedRef<boolean>;
+}
+/**
+ * Provider-agnostic Convex auth state.
+ *
+ * Call once with `{ fetchToken }` (typically in a client plugin) to wire
+ * `ConvexClient.setAuth` + token refresh. Call without args anywhere to read
+ * `{ isLoading, isAuthenticated, isRefreshing, hasSsrSession }`.
+ *
+ * Same contract as React `useConvexAuth` / `ConvexProviderWithAuth`.
+ */
+export declare function useConvexAuth(setup?: UseConvexAuthSetupOptions): UseConvexAuthReturn;

package/dist/runtime/composables/useConvexAuth.js

@@ -0,0 +1,96 @@
+import {
+  computed,
+  toValue,
+  watch
+} from "vue";
+import { useHasSsrSessionRef } from "../utils/authCookie.js";
+import { useConvexContext } from "../utils/context.js";
+import { resolveConvexAuthState } from "../utils/authState.js";
+export function useConvexAuth(setup) {
+  const ctx = useConvexContext();
+  const auth = ctx.auth;
+  const hasSsrSession = useHasSsrSessionRef();
+  const showAuthedUi = computed(
+    () => auth.isAuthenticated.value || hasSsrSession.value
+  );
+  if (setup) {
+    if (import.meta.server) {
+      return {
+        isLoading: computed(() => auth.isLoading.value),
+        isAuthenticated: computed(() => auth.isAuthenticated.value),
+        isRefreshing: computed(() => auth.isRefreshing.value),
+        hasSsrSession,
+        showAuthedUi
+      };
+    }
+    const client = ctx.client;
+    if (!client) {
+      throw new Error(
+        "[convex-nuxt] useConvexAuth({ fetchToken }) requires ConvexClient (browser only)."
+      );
+    }
+    auth.fetchToken = setup.fetchToken;
+    auth.configured = true;
+    const syncFromProvider = () => {
+      const providerLoading = toValue(setup.isLoading) ?? false;
+      const providerAuthenticated = toValue(setup.isAuthenticated) ?? true;
+      auth.providerLoading.value = providerLoading;
+      auth.providerAuthenticated.value = providerAuthenticated;
+      if (providerLoading) {
+        auth.isConvexAuthenticated.value = null;
+        auth.isRefreshingRaw.value = false;
+        applyAuthState(auth);
+        return;
+      }
+      if (!providerAuthenticated) {
+        auth.isConvexAuthenticated.value = false;
+        auth.isRefreshingRaw.value = false;
+        try {
+          client.client.clearAuth();
+        } catch {
+        }
+        applyAuthState(auth);
+        return;
+      }
+      auth.isConvexAuthenticated.value = null;
+      applyAuthState(auth);
+      client.client.setAuth(
+        setup.fetchToken,
+        (backendReportsIsAuthenticated) => {
+          auth.isConvexAuthenticated.value = backendReportsIsAuthenticated;
+          applyAuthState(auth);
+        },
+        (isRefreshing) => {
+          auth.isRefreshingRaw.value = isRefreshing;
+          applyAuthState(auth);
+        }
+      );
+    };
+    watch(
+      () => [
+        toValue(setup.isLoading) ?? false,
+        toValue(setup.isAuthenticated) ?? true
+      ],
+      syncFromProvider,
+      { immediate: true }
+    );
+  }
+  return {
+    isLoading: computed(() => auth.isLoading.value),
+    isAuthenticated: computed(() => auth.isAuthenticated.value),
+    isRefreshing: computed(() => auth.isRefreshing.value),
+    hasSsrSession,
+    showAuthedUi
+  };
+}
+function applyAuthState(auth) {
+  const next = resolveConvexAuthState({
+    authProviderLoading: auth.providerLoading.value,
+    authProviderAuthenticated: auth.providerAuthenticated.value,
+    isConvexAuthenticated: auth.isConvexAuthenticated.value,
+    isRefreshing: auth.isRefreshingRaw.value
+  });
+  auth.isLoading.value = next.isLoading;
+  auth.isAuthenticated.value = next.isAuthenticated;
+  auth.isRefreshing.value = next.isRefreshing;
+}

package/dist/runtime/composables/useConvexConnectionState.d.ts

@@ -0,0 +1,8 @@
+import type { ConnectionState } from 'convex/browser';
+import { type ShallowRef } from 'vue';
+export type { ConnectionState };
+/**
+ * Reactive WebSocket {@link ConnectionState} for the browser ConvexClient.
+ * Returns `null` during SSR or when the client is unavailable.
+ */
+export declare function useConvexConnectionState(): ShallowRef<ConnectionState | null>;

package/dist/runtime/composables/useConvexConnectionState.js

@@ -0,0 +1,21 @@
+import { onScopeDispose, shallowRef } from "vue";
+import { useConvexContext } from "../utils/context.js";
+export function useConvexConnectionState() {
+  const state = shallowRef(null);
+  if (import.meta.server) {
+    return state;
+  }
+  const ctx = useConvexContext();
+  const client = ctx.client;
+  if (!client) {
+    return state;
+  }
+  state.value = client.connectionState();
+  const unsubscribe = client.subscribeToConnectionState((next) => {
+    state.value = next;
+  });
+  onScopeDispose(() => {
+    unsubscribe();
+  });
+  return state;
+}

package/dist/runtime/composables/useConvexGate.d.ts

@@ -0,0 +1,20 @@
+import { type ComputedRef } from 'vue';
+export interface ConvexGate {
+    isLoading: ComputedRef<boolean>;
+    isAuthenticated: ComputedRef<boolean>;
+    isRefreshing: ComputedRef<boolean>;
+    hasSsrSession: ComputedRef<boolean>;
+    showAuthedUi: ComputedRef<boolean>;
+    /** True while resolving auth and the authed shell is not yet shown. */
+    showLoading: ComputedRef<boolean>;
+    /** True when signed out (no cookie, not authenticated, not loading). */
+    showSignedOut: ComputedRef<boolean>;
+    /** True while refreshing a rejected token for an authenticated session. */
+    showRefreshing: ComputedRef<boolean>;
+}
+/**
+ * Convenience gate flags for auth UI. Same values as the
+ * `Authenticated` / `Unauthenticated` / `AuthLoading` / `AuthRefreshing`
+ * components.
+ */
+export declare function useConvexGate(): ConvexGate;

package/dist/runtime/composables/useConvexGate.js

@@ -0,0 +1,21 @@
+import { computed } from "vue";
+import { useConvexAuth } from "../composables/useConvexAuth.js";
+export function useConvexGate() {
+  const auth = useConvexAuth();
+  return {
+    isLoading: auth.isLoading,
+    isAuthenticated: auth.isAuthenticated,
+    isRefreshing: auth.isRefreshing,
+    hasSsrSession: auth.hasSsrSession,
+    showAuthedUi: auth.showAuthedUi,
+    showLoading: computed(
+      () => auth.isLoading.value && !auth.showAuthedUi.value
+    ),
+    showSignedOut: computed(
+      () => !auth.showAuthedUi.value && !auth.isLoading.value
+    ),
+    showRefreshing: computed(
+      () => auth.isAuthenticated.value && auth.isRefreshing.value
+    )
+  };
+}

package/dist/runtime/composables/useConvexMutation.d.ts

@@ -0,0 +1,25 @@
+import type { FunctionArgs, FunctionReference, FunctionReturnType } from 'convex/server';
+import type { OptimisticUpdate } from 'convex/browser';
+import { type MaybeRefOrGetter } from 'vue';
+export type { OptimisticUpdate };
+export interface UseConvexMutationOptions<Mutation extends FunctionReference<'mutation'>> {
+    /**
+     * Local query update applied while the mutation is in flight.
+     * Passed through to `ConvexClient.mutation` → `BaseConvexClient`.
+     */
+    optimisticUpdate?: OptimisticUpdate<FunctionArgs<Mutation>>;
+}
+/**
+ * Browser mutation helper. Returns `{ mutate, error, pending }`.
+ *
+ * Safe to call during SSR setup — the ConvexClient is only touched when
+ * `mutate()` runs in the browser.
+ *
+ * Pass `{ optimisticUpdate }` to apply temporary local query results while
+ * the mutation is in flight (same contract as React `withOptimisticUpdate`).
+ */
+export declare function useConvexMutation<Mutation extends FunctionReference<'mutation'>>(mutation: Mutation, options?: UseConvexMutationOptions<Mutation>): {
+    mutate: (args?: MaybeRefOrGetter<FunctionArgs<Mutation>>) => Promise<FunctionReturnType<Mutation>>;
+    error: import("vue").Ref<Error | null, Error | null>;
+    pending: import("vue").ComputedRef<boolean>;
+};

package/dist/runtime/composables/useConvexMutation.js

@@ -0,0 +1,35 @@
+import { computed, ref, toValue } from "vue";
+import { useConvexContext } from "../utils/context.js";
+export function useConvexMutation(mutation, options = {}) {
+  const ctx = useConvexContext();
+  const error = ref(null);
+  const pendingCount = ref(0);
+  const mutate = async (args = {}) => {
+    if (import.meta.server || !ctx.client) {
+      throw new Error(
+        "[convex-nuxt] useConvexMutation can only run in the browser."
+      );
+    }
+    pendingCount.value++;
+    error.value = null;
+    try {
+      const resolved = toValue(args);
+      return await ctx.client.mutation(
+        mutation,
+        resolved,
+        options.optimisticUpdate ? { optimisticUpdate: options.optimisticUpdate } : void 0
+      );
+    } catch (cause) {
+      const err = cause instanceof Error ? cause : new Error(String(cause));
+      error.value = err;
+      throw err;
+    } finally {
+      pendingCount.value--;
+    }
+  };
+  return {
+    mutate,
+    error,
+    pending: computed(() => pendingCount.value > 0)
+  };
+}

package/dist/runtime/composables/useConvexPaginatedQuery.d.ts

@@ -0,0 +1,43 @@
+import type { FunctionArgs, FunctionReference, FunctionReturnType, PaginationOptions, PaginationResult } from 'convex/server';
+import { type ComputedRef, type MaybeRefOrGetter, type Ref } from 'vue';
+/**
+ * A query usable with {@link useConvexPaginatedQuery}.
+ * Must accept `paginationOpts` and return {@link PaginationResult}.
+ */
+export type PaginatedQueryReference = FunctionReference<'query', 'public', {
+    paginationOpts: PaginationOptions;
+}, PaginationResult<any>>;
+export type PaginatedQueryArgs<Query extends PaginatedQueryReference> = Omit<FunctionArgs<Query>, 'paginationOpts'>;
+export type PaginatedQueryItem<Query extends PaginatedQueryReference> = FunctionReturnType<Query>['page'][number];
+export type PaginationStatus = 'LoadingFirstPage' | 'CanLoadMore' | 'LoadingMore' | 'Exhausted';
+export interface UseConvexPaginatedQueryOptions {
+    /** Items to load on the first page (and default for `loadMore`). */
+    initialNumItems: number;
+    /** Explicit Nuxt payload key for the first page. */
+    key?: string;
+    /** SSR the first page via HttpClient. Defaults to `convex.server`. */
+    server?: boolean;
+    /** JWT for the SSR / HttpClient first page. */
+    token?: string;
+    /**
+     * Skip first-page HttpClient and live paginated subscribe until Convex
+     * confirms auth. Same contract as `useConvexQuery({ authenticated: true })`.
+     * @default false
+     */
+    authenticated?: boolean;
+}
+export type UseConvexPaginatedQueryReturn<Query extends PaginatedQueryReference> = {
+    results: ComputedRef<Array<PaginatedQueryItem<Query>>>;
+    status: ComputedRef<PaginationStatus>;
+    isLoading: ComputedRef<boolean>;
+    loadMore: (numItems?: number) => void;
+    error: Ref<Error | null>;
+};
+/**
+ * Paginated Convex query with SSR for the first page and live multi-page updates.
+ *
+ * On the browser this uses `ConvexClient.onPaginatedUpdate_experimental` so
+ * every loaded page stays reactive (React `usePaginatedQuery` parity). The SSR
+ * snapshot hydrates the first page until the live subscription is ready.
+ */
+export declare function useConvexPaginatedQuery<Query extends PaginatedQueryReference>(query: Query, args: MaybeRefOrGetter<PaginatedQueryArgs<Query> | "skip"> | undefined, options: UseConvexPaginatedQueryOptions): Promise<UseConvexPaginatedQueryReturn<Query>>;

package/dist/runtime/composables/useConvexPaginatedQuery.js

@@ -0,0 +1,188 @@
+import { convexToJson, jsonToConvex } from "convex/values";
+import { useAsyncData, useNuxtApp, useRuntimeConfig } from "nuxt/app";
+import {
+  computed,
+  onScopeDispose,
+  ref,
+  shallowRef,
+  toValue,
+  watch
+} from "vue";
+import { resolveAuthGatedArgs } from "../utils/authGate.js";
+import { useConvexContext } from "../utils/context.js";
+import { convexQueryKey } from "../utils/queryKey.js";
+function mapLiveStatus(status) {
+  switch (status) {
+    case "LoadingFirstPage":
+      return "LoadingFirstPage";
+    case "LoadingMore":
+      return "LoadingMore";
+    case "Exhausted":
+      return "Exhausted";
+    case "CanLoadMore":
+      return "CanLoadMore";
+  }
+}
+export async function useConvexPaginatedQuery(query, args = {}, options) {
+  if (options.initialNumItems <= 0) {
+    throw new Error(
+      "[convex-nuxt] useConvexPaginatedQuery initialNumItems must be > 0"
+    );
+  }
+  const runtimeConfig = useRuntimeConfig();
+  const defaultServer = runtimeConfig.public.convex?.server;
+  const server = options.server ?? defaultServer ?? true;
+  const requireAuth = options.authenticated ?? false;
+  const ctx = useConvexContext();
+  const resolveRawArgs = () => toValue(args);
+  const resolveEffectiveArgs = () => resolveAuthGatedArgs(resolveRawArgs(), {
+    authenticated: requireAuth,
+    isAuthenticated: ctx.auth.isAuthenticated.value
+  });
+  const firstPageArgsFrom = (base) => {
+    if (base === "skip") {
+      return "skip";
+    }
+    return {
+      ...base,
+      paginationOpts: {
+        numItems: options.initialNumItems,
+        cursor: null
+      }
+    };
+  };
+  const key = computed(
+    () => convexQueryKey(query, firstPageArgsFrom(resolveRawArgs()), options.key)
+  );
+  const asyncData = await useAsyncData(
+    key,
+    async () => {
+      const pageArgs = firstPageArgsFrom(resolveEffectiveArgs());
+      if (pageArgs === "skip") {
+        return null;
+      }
+      const token = options.token ?? ctx.ssrToken.value;
+      if (requireAuth && import.meta.client && !token) {
+        const nuxtApp = useNuxtApp();
+        const cached = nuxtApp.payload.data[toValue(key)];
+        return cached ?? null;
+      }
+      const http = ctx.createHttpClient({ token });
+      const result = await http.query(
+        query,
+        pageArgs
+      );
+      return jsonToConvex(convexToJson(result));
+    },
+    {
+      server,
+      watch: [
+        () => toValue(args),
+        () => options.token ?? ctx.ssrToken.value,
+        () => requireAuth && ctx.auth.isAuthenticated.value && !!(options.token ?? ctx.ssrToken.value)
+      ]
+    }
+  );
+  const live = shallowRef(null);
+  const liveReady = ref(false);
+  const error = ref(null);
+  const liveLoadMore = shallowRef(null);
+  const results = computed(() => {
+    if (resolveEffectiveArgs() === "skip") {
+      return asyncData.data.value?.page ?? [];
+    }
+    if (liveReady.value && live.value) {
+      return live.value.results;
+    }
+    return asyncData.data.value?.page ?? [];
+  });
+  const status = computed(() => {
+    if (resolveEffectiveArgs() === "skip") {
+      if (asyncData.data.value) {
+        return asyncData.data.value.isDone ? "Exhausted" : "CanLoadMore";
+      }
+      return "Exhausted";
+    }
+    if (liveReady.value && live.value) {
+      return mapLiveStatus(live.value.status);
+    }
+    if (asyncData.pending.value || import.meta.client && !liveReady.value) {
+      if (asyncData.data.value) {
+        return asyncData.data.value.isDone ? "Exhausted" : "CanLoadMore";
+      }
+      return "LoadingFirstPage";
+    }
+    if (asyncData.data.value) {
+      return asyncData.data.value.isDone ? "Exhausted" : "CanLoadMore";
+    }
+    return "LoadingFirstPage";
+  });
+  const isLoading = computed(
+    () => status.value === "LoadingFirstPage" || status.value === "LoadingMore"
+  );
+  if (import.meta.client && ctx.client) {
+    const client = ctx.client;
+    let cancel;
+    const subscribe = () => {
+      cancel?.();
+      cancel = void 0;
+      liveReady.value = false;
+      live.value = null;
+      liveLoadMore.value = null;
+      error.value = null;
+      const base = resolveEffectiveArgs();
+      if (base === "skip") {
+        liveReady.value = true;
+        return;
+      }
+      cancel = client.onPaginatedUpdate_experimental(
+        query,
+        base,
+        { initialNumItems: options.initialNumItems },
+        (result) => {
+          const page = result;
+          live.value = page;
+          liveLoadMore.value = page.loadMore;
+          liveReady.value = true;
+          error.value = null;
+        },
+        (err) => {
+          error.value = err;
+          liveReady.value = true;
+        }
+      );
+    };
+    watch(
+      () => [
+        toValue(args),
+        options.initialNumItems,
+        ctx.auth.isAuthenticated.value
+      ],
+      subscribe,
+      { immediate: true }
+    );
+    onScopeDispose(() => {
+      cancel?.();
+    });
+  }
+  const loadMore = (numItems = options.initialNumItems) => {
+    if (import.meta.server || !ctx.client) {
+      return;
+    }
+    if (status.value !== "CanLoadMore") {
+      return;
+    }
+    const fn = liveLoadMore.value;
+    if (!fn) {
+      return;
+    }
+    fn(numItems);
+  };
+  return {
+    results,
+    status,
+    isLoading,
+    loadMore,
+    error
+  };
+}

package/dist/runtime/composables/useConvexQueries.d.ts

@@ -0,0 +1,27 @@
+import type { FunctionReference, FunctionReturnType } from 'convex/server';
+import type { Value } from 'convex/values';
+import { type ComputedRef, type MaybeRefOrGetter } from 'vue';
+export type ConvexQueriesRequest = Record<string, {
+    query: FunctionReference<'query'>;
+    args: Record<string, Value>;
+} | 'skip'>;
+export type ConvexQueriesResult<Request extends ConvexQueriesRequest> = {
+    [K in keyof Request]: Request[K] extends {
+        query: infer Query;
+        args: any;
+    } ? Query extends FunctionReference<'query'> ? FunctionReturnType<Query> | undefined | Error : undefined : undefined;
+};
+/**
+ * Subscribe to a dynamic map of Convex queries (React `useQueries` parity).
+ *
+ * Pass a reactive object whose values are `{ query, args }` or `'skip'`.
+ * Returns a computed map of the same keys → result | `undefined` (loading) |
+ * `Error`.
+ *
+ * Browser-only live subscriptions. During SSR every entry is `undefined`
+ * (combine with `useConvexQuery` when you need SSR for known queries).
+ *
+ * Unchanged keys (same function name + args) keep their existing subscription
+ * so deep reactive churn does not tear down WebSocket watches.
+ */
+export declare function useConvexQueries<Request extends ConvexQueriesRequest>(queries: MaybeRefOrGetter<Request>): ComputedRef<ConvexQueriesResult<Request>>;