better-convex 0.9.2 → 0.10.0

package/dist/types-7bF_8IjP.d.ts

@@ -0,0 +1,213 @@
+import { H as CombinedDataTransformer, n as HttpClientError } from "./http-types-BK7FuIcR.js";
+import { FunctionArgs, FunctionReference, FunctionReturnType } from "convex/server";
+
+//#region src/crpc/http-client.d.ts
+/** Form value types (matches Hono's FormValue) */
+type HttpFormValue = string | Blob;
+/**
+ * Hybrid input args: JSON body fields at root, explicit params/searchParams/form.
+ * - JSON body: spread at root level (tRPC-style)
+ * - Path params: { params: { id: '123' } }
+ * - Query params: { searchParams: { limit: '10' } }
+ * - Form data: { form: { file: blob } } - typed via .form() builder
+ * - Client options: { headers, fetch, init } - for per-call customization
+ */
+type HttpInputArgs = {
+  /** Path parameters (e.g., :id in /users/:id) */params?: Record<string, string>; /** Query string parameters */
+  searchParams?: Record<string, string | string[]>; /** Form data body (Content-Type: multipart/form-data) - typed via .form() builder */
+  form?: Record<string, HttpFormValue | HttpFormValue[]>; /** Custom fetch function (per-call override) */
+  fetch?: typeof fetch; /** Standard RequestInit (per-call override) */
+  init?: RequestInit; /** Additional headers (per-call override) */
+  headers?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>); /** Any other properties are JSON body fields */
+  [key: string]: unknown;
+};
+/**
+ * Client request options (matches Hono's ClientRequestOptions).
+ * Standard RequestInit in `init` takes highest priority and can override
+ * things that are set automatically like body, method, headers.
+ */
+type HttpClientOptions = {
+  /** Custom fetch function */fetch?: typeof fetch;
+  /**
+   * Standard RequestInit - takes highest priority.
+   * Can override body, method, headers if needed.
+   */
+  init?: RequestInit; /** Additional headers (or async function returning headers) */
+  headers?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
+};
+/** HTTP proxy options (framework-agnostic parts) */
+interface HttpProxyBaseOptions {
+  /** Base URL for the Convex HTTP API (e.g., https://your-site.convex.site) */
+  convexSiteUrl: string;
+  /** Custom fetch function (defaults to global fetch) */
+  fetch?: typeof fetch;
+  /** Default headers or async function returning headers (for auth tokens) */
+  headers?: {
+    [key: string]: string | undefined;
+  } | (() => {
+    [key: string]: string | undefined;
+  } | Promise<{
+    [key: string]: string | undefined;
+  }>);
+  /** Error handler called on HTTP errors */
+  onError?: (error: HttpClientError) => void;
+}
+/** Reserved keys that are not part of JSON body */
+declare const RESERVED_KEYS: Set<string>;
+/**
+ * Replace URL path parameters with actual values.
+ * e.g., '/users/:id' with { id: '123' } -> '/users/123'
+ */
+declare function replaceUrlParam(url: string, params: Record<string, string>): string;
+/**
+ * Build URLSearchParams from query object.
+ * Handles array values as multiple params with same key (like Hono).
+ */
+declare function buildSearchParams(query: Record<string, string | string[]>): URLSearchParams;
+/**
+ * Hono-style HTTP request executor.
+ * Processes args in the same way as Hono's ClientRequestImpl.fetch().
+ */
+declare function executeHttpRequest(opts: {
+  convexSiteUrl: string;
+  route: {
+    path: string;
+    method: string;
+  };
+  procedureName: string; /** Hono-style input args */
+  args?: HttpInputArgs; /** Per-request client options */
+  clientOpts?: HttpClientOptions; /** Base headers from proxy config */
+  baseHeaders?: {
+    [key: string]: string | undefined;
+  } | (() => {
+    [key: string]: string | undefined;
+  } | Promise<{
+    [key: string]: string | undefined;
+  }>); /** Base fetch from proxy config */
+  baseFetch?: typeof fetch; /** Wire transformer for payload serialization. */
+  transformer: CombinedDataTransformer;
+}): Promise<unknown>;
+//#endregion
+//#region src/crpc/types.d.ts
+/** Symbol key for attaching FunctionReference to options (non-serializable) */
+declare const FUNC_REF_SYMBOL: unique symbol;
+/** Options controlled by convexQuery/convexAction factories */
+type ReservedQueryOptions = 'queryKey' | 'queryFn' | 'staleTime';
+/** Options controlled by mutation factories */
+type ReservedMutationOptions = 'mutationFn';
+/** Reserved options controlled by infinite query factories */
+type ReservedInfiniteQueryOptions = 'queryKey' | 'queryFn' | 'staleTime' | 'refetchInterval' | 'refetchOnMount' | 'refetchOnReconnect' | 'refetchOnWindowFocus' | 'persister' | 'placeholderData';
+/** Metadata for a single Convex function */
+type FnMeta = {
+  auth?: 'required' | 'optional';
+  role?: string;
+  rateLimit?: string;
+  type?: 'query' | 'mutation' | 'action';
+  limit?: number;
+  [key: string]: unknown;
+};
+/** Metadata for paginated functions (limit is required) */
+type PaginatedFnMeta = Omit<FnMeta, 'limit'> & {
+  limit: number;
+};
+/** Metadata for all Convex functions by namespace.fnName, with _http for HTTP routes */
+type Meta = Record<string, Record<string, FnMeta>> & {
+  _http?: Record<string, {
+    path: string;
+    method: string;
+  }>;
+};
+/** Authentication requirement for a Convex function */
+type AuthType = 'required' | 'optional' | undefined;
+/** Query key structure for Convex queries */
+type ConvexQueryKey<T extends FunctionReference<'query'>> = readonly ['convexQuery', string, FunctionArgs<T>];
+/** Query key structure for Convex actions */
+type ConvexActionKey<T extends FunctionReference<'action'>> = readonly ['convexAction', string, FunctionArgs<T>];
+/** Mutation key structure for Convex mutations/actions */
+type ConvexMutationKey = ['convexMutation', string];
+/**
+ * Meta passed to TanStack Query for auth and subscription control.
+ * Set by convexQuery, read by ConvexQueryClient.queryFn() and subscribeInner().
+ */
+type ConvexQueryMeta = {
+  /** Auth type from generated Convex metadata via getMeta() */authType?: 'required' | 'optional'; /** Skip query silently when unauthenticated (returns null) */
+  skipUnauth?: boolean; /** Whether to create WebSocket subscription (default: true) */
+  subscribe?: boolean;
+};
+/** Hook options for Convex queries */
+type ConvexQueryHookOptions = {
+  /** Skip query silently when unauthenticated (default: false, calls onQueryUnauthorized) */skipUnauth?: boolean; /** Set to false to fetch once without subscribing (default: true) */
+  subscribe?: boolean;
+};
+/** Internal Convex pagination options (used by .paginate()) */
+type PaginationOpts = {
+  cursor: string | null;
+  numItems: number;
+  endCursor?: string | null;
+  id?: number;
+  maximumRowsRead?: number;
+  maximumBytesRead?: number;
+};
+/** Extract input args without cursor/limit (user's filter args only) */
+type InfiniteQueryInput<TInput> = Omit<TInput, 'cursor' | 'limit'>;
+/** Extract item type from PaginationResult<T> */
+type ExtractPaginatedItem<TOutput> = TOutput extends {
+  page: (infer T)[];
+} ? T : never;
+/** Metadata for infinite query (extends ConvexQueryMeta) */
+type ConvexInfiniteQueryMeta = ConvexQueryMeta & {
+  /** The query function name (serializable for RSC) */queryName: string; /** Query args without cursor/limit (user's filter args only) */
+  args: Record<string, unknown>; /** Items per page (optional - server uses .paginated() default) */
+  limit?: number;
+};
+type EmptyObject = Record<string, never>;
+/** Static query options parameter type (non-hook, for event handlers) */
+type StaticQueryOptsParam = {
+  skipUnauth?: boolean;
+};
+/** Check if a type has cursor key (pagination detection) */
+type IsPaginated<T> = 'cursor' extends keyof T ? true : false;
+/** Mutation variables type - undefined when no args required (allows mutateAsync() without args) */
+type MutationVariables<T extends FunctionReference<'mutation' | 'action'>> = keyof FunctionArgs<T> extends never ? void : EmptyObject extends FunctionArgs<T> ? FunctionArgs<T> | undefined : FunctionArgs<T>;
+/** Base query options shape returned by convexQuery factory */
+type BaseConvexQueryOptions<T extends FunctionReference<'query'>> = {
+  queryKey: ConvexQueryKey<T>;
+  staleTime?: number;
+  enabled?: unknown;
+};
+/** Base action options shape returned by convexAction factory */
+type BaseConvexActionOptions<T extends FunctionReference<'action'>> = {
+  queryKey: ConvexActionKey<T>;
+  staleTime?: number;
+  enabled?: unknown;
+};
+/** Base infinite query options parameter */
+type BaseInfiniteQueryOptsParam<T extends FunctionReference<'query'> = FunctionReference<'query'>> = {
+  /** Items per page. Optional - server uses .paginated() default if not provided. */limit?: number; /** Skip query silently when unauthenticated */
+  skipUnauth?: boolean; /** Placeholder data shown while loading (item array, not pagination result) */
+  placeholderData?: ExtractPaginatedItem<FunctionReturnType<T>>[]; /** Whether the query is enabled */
+  enabled?: unknown;
+};
+/** Base infinite query options shape */
+type BaseConvexInfiniteQueryOptions<T extends FunctionReference<'query'>> = {
+  queryKey: ConvexQueryKey<T>;
+  staleTime?: number;
+  enabled?: unknown;
+  meta: ConvexInfiniteQueryMeta;
+  refetchInterval: false;
+  refetchOnMount: false;
+  refetchOnReconnect: false;
+  refetchOnWindowFocus: false; /** Placeholder data shown while loading (item array, not pagination result) */
+  placeholderData?: ExtractPaginatedItem<FunctionReturnType<T>>[];
+};
+/** Vanilla mutation - direct .mutate() call without TanStack Query */
+type VanillaMutation<T extends FunctionReference<'mutation'>> = {
+  mutate: keyof FunctionArgs<T> extends never ? (args?: EmptyObject) => Promise<FunctionReturnType<T>> : EmptyObject extends FunctionArgs<T> ? (args?: FunctionArgs<T>) => Promise<FunctionReturnType<T>> : (args: FunctionArgs<T>) => Promise<FunctionReturnType<T>>;
+};
+/** Vanilla action - both .query() and .mutate() for direct calls */
+type VanillaAction<T extends FunctionReference<'action'>> = {
+  query: keyof FunctionArgs<T> extends never ? (args?: EmptyObject) => Promise<FunctionReturnType<T>> : EmptyObject extends FunctionArgs<T> ? (args?: FunctionArgs<T>) => Promise<FunctionReturnType<T>> : (args: FunctionArgs<T>) => Promise<FunctionReturnType<T>>;
+  mutate: keyof FunctionArgs<T> extends never ? (args?: EmptyObject) => Promise<FunctionReturnType<T>> : EmptyObject extends FunctionArgs<T> ? (args?: FunctionArgs<T>) => Promise<FunctionReturnType<T>> : (args: FunctionArgs<T>) => Promise<FunctionReturnType<T>>;
+};
+//#endregion
+export { HttpInputArgs as A, ReservedMutationOptions as C, VanillaMutation as D, VanillaAction as E, replaceUrlParam as F, RESERVED_KEYS as M, buildSearchParams as N, HttpClientOptions as O, executeHttpRequest as P, ReservedInfiniteQueryOptions as S, StaticQueryOptsParam as T, IsPaginated as _, BaseInfiniteQueryOptsParam as a, PaginatedFnMeta as b, ConvexMutationKey as c, ConvexQueryMeta as d, EmptyObject as f, InfiniteQueryInput as g, FnMeta as h, BaseConvexQueryOptions as i, HttpProxyBaseOptions as j, HttpFormValue as k, ConvexQueryHookOptions as l, FUNC_REF_SYMBOL as m, BaseConvexActionOptions as n, ConvexActionKey as o, ExtractPaginatedItem as p, BaseConvexInfiniteQueryOptions as r, ConvexInfiniteQueryMeta as s, AuthType as t, ConvexQueryKey as u, Meta as v, ReservedQueryOptions as w, PaginationOpts as x, MutationVariables as y };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "better-convex",
-  "version": "0.9.2",
+  "version": "0.10.0",
   "description": "Better Convex - React Query integration and CLI tools for Convex",
   "keywords": [
     "convex",
@@ -26,6 +26,7 @@
     "./react": "./dist/react/index.js",
     "./rsc": "./dist/rsc/index.js",
     "./server": "./dist/server/index.js",
+    "./solid": "./dist/solid/index.js",
     "./package.json": "./package.json"
   },
   "bin": {
@@ -59,18 +60,28 @@
   "devDependencies": {
     "@rollup/plugin-babel": "^6.1.0",
     "babel-plugin-react-compiler": "^1.0.0",
+    "rolldown-plugin-solid": "^0.2.1",
     "tsdown": "^0.20.3"
   },
   "peerDependencies": {
+    "@tanstack/query-core": ">=5",
     "@tanstack/react-query": ">=5",
+    "@tanstack/solid-query": ">=5",
     "better-auth": ">=1.4.9",
     "convex": ">=1.32",
     "hono": ">=4",
     "next": ">=14",
     "react": ">=18",
+    "solid-js": ">=1.8",
     "zod": ">=4"
   },
   "peerDependenciesMeta": {
+    "@tanstack/react-query": {
+      "optional": true
+    },
+    "@tanstack/solid-query": {
+      "optional": true
+    },
     "better-auth": {
       "optional": true
     },
@@ -82,6 +93,9 @@
     },
     "react": {
       "optional": true
+    },
+    "solid-js": {
+      "optional": true
     }
   },
   "publishConfig": {

package/dist/types-f53SgpBL.d.ts

@@ -1,221 +0,0 @@
-import { n as DeepPartial, o as Simplify, r as DistributiveOmit } from "./types-BTb_4BaU.js";
-import { FunctionArgs, FunctionReference, FunctionReturnType } from "convex/server";
-import { DefaultError, QueryFilters, SkipToken, UseMutationOptions, UseQueryOptions } from "@tanstack/react-query";
-import { Watch, WatchQueryOptions } from "convex/react";
-
-//#region src/crpc/types.d.ts
-/** Symbol key for attaching FunctionReference to options (non-serializable) */
-declare const FUNC_REF_SYMBOL: unique symbol;
-/** Options controlled by convexQuery/convexAction factories */
-type ReservedQueryOptions = 'queryKey' | 'queryFn' | 'staleTime';
-/** Options controlled by mutation factories */
-type ReservedMutationOptions = 'mutationFn';
-/** Metadata for a single Convex function */
-type FnMeta = {
-  auth?: 'required' | 'optional';
-  role?: string;
-  rateLimit?: string;
-  type?: 'query' | 'mutation' | 'action';
-  limit?: number;
-  [key: string]: unknown;
-};
-/** Metadata for paginated functions (limit is required) */
-type PaginatedFnMeta = Omit<FnMeta, 'limit'> & {
-  limit: number;
-};
-/** Metadata for all Convex functions by namespace.fnName, with _http for HTTP routes */
-type Meta = Record<string, Record<string, FnMeta>> & {
-  _http?: Record<string, {
-    path: string;
-    method: string;
-  }>;
-};
-/** Authentication requirement for a Convex function */
-type AuthType = 'required' | 'optional' | undefined;
-/** Query key structure for Convex queries */
-type ConvexQueryKey<T extends FunctionReference<'query'>> = readonly ['convexQuery', string, FunctionArgs<T>];
-/** Query key structure for Convex actions */
-type ConvexActionKey<T extends FunctionReference<'action'>> = readonly ['convexAction', string, FunctionArgs<T>];
-/** Mutation key structure for Convex mutations/actions */
-type ConvexMutationKey = ['convexMutation', string];
-/**
- * Meta passed to TanStack Query for auth and subscription control.
- * Set by convexQuery, read by ConvexQueryClient.queryFn() and subscribeInner().
- */
-type ConvexQueryMeta = {
-  /** Auth type from generated Convex metadata via getMeta() */authType?: 'required' | 'optional'; /** Skip query silently when unauthenticated (returns null) */
-  skipUnauth?: boolean; /** Whether to create WebSocket subscription (default: true) */
-  subscribe?: boolean;
-};
-/** Options returned by `convexQuery` factory */
-type ConvexQueryOptions<T extends FunctionReference<'query'>> = Pick<UseQueryOptions<FunctionReturnType<T>, Error, FunctionReturnType<T>, ConvexQueryKey<T>>, 'queryKey' | 'staleTime' | 'enabled'>;
-/** Options returned by `convexAction` factory */
-type ConvexActionOptions<T extends FunctionReference<'action'>> = Pick<UseQueryOptions<FunctionReturnType<T>, Error, FunctionReturnType<T>, ConvexActionKey<T>>, 'queryKey' | 'staleTime' | 'enabled'>;
-/** Hook options for Convex queries */
-type ConvexQueryHookOptions = {
-  /** Skip query silently when unauthenticated (default: false, calls onQueryUnauthorized) */skipUnauth?: boolean; /** Set to false to fetch once without subscribing (default: true) */
-  subscribe?: boolean;
-};
-/** Internal Convex pagination options (used by .paginate()) */
-type PaginationOpts = {
-  cursor: string | null;
-  numItems: number;
-  endCursor?: string | null;
-  id?: number;
-  maximumRowsRead?: number;
-  maximumBytesRead?: number;
-};
-/** Extract input args without cursor/limit (user's filter args only) */
-type InfiniteQueryInput<TInput> = Omit<TInput, 'cursor' | 'limit'>;
-/** Extract item type from PaginationResult<T> */
-type ExtractPaginatedItem<TOutput> = TOutput extends {
-  page: (infer T)[];
-} ? T : never;
-type EmptyObject = Record<string, never>;
-/** Query options parameter type */
-type QueryOptsParam<T extends FunctionReference<'query'>> = Simplify<ConvexQueryHookOptions & DistributiveOmit<UseQueryOptions<FunctionReturnType<T>, DefaultError>, ReservedQueryOptions>>;
-/** Query options return type */
-type QueryOptsReturn<T extends FunctionReference<'query'>> = ConvexQueryOptions<T> & {
-  meta: ConvexQueryMeta;
-};
-/** Action query options parameter type (actions don't support subscriptions) */
-type ActionQueryOptsParam<T extends FunctionReference<'action'>> = DistributiveOmit<UseQueryOptions<FunctionReturnType<T>, DefaultError>, ReservedQueryOptions>;
-/** Action query options return type */
-type ActionQueryOptsReturn<T extends FunctionReference<'action'>> = ConvexActionOptions<T>;
-/**
- * Decorated query procedure with queryOptions, queryKey, and queryFilter methods.
- * Args are optional when the function has no required parameters.
- * Supports skipToken for type-safe conditional queries.
- */
-/** Static query options parameter type (non-hook, for event handlers) */
-type StaticQueryOptsParam = {
-  skipUnauth?: boolean;
-};
-type DecorateQuery<T extends FunctionReference<'query'>> = {
-  queryOptions: keyof FunctionArgs<T> extends never ? (args?: EmptyObject | SkipToken, opts?: QueryOptsParam<T>) => QueryOptsReturn<T> : EmptyObject extends FunctionArgs<T> ? (args?: FunctionArgs<T> | SkipToken, opts?: QueryOptsParam<T>) => QueryOptsReturn<T> : (args: FunctionArgs<T> | SkipToken, opts?: QueryOptsParam<T>) => QueryOptsReturn<T>; /** Static (non-hook) query options for event handlers and prefetching */
-  staticQueryOptions: keyof FunctionArgs<T> extends never ? (args?: EmptyObject | SkipToken, opts?: StaticQueryOptsParam) => ConvexQueryOptions<T> & {
-    meta: ConvexQueryMeta;
-  } : EmptyObject extends FunctionArgs<T> ? (args?: FunctionArgs<T> | SkipToken, opts?: StaticQueryOptsParam) => ConvexQueryOptions<T> & {
-    meta: ConvexQueryMeta;
-  } : (args: FunctionArgs<T> | SkipToken, opts?: StaticQueryOptsParam) => ConvexQueryOptions<T> & {
-    meta: ConvexQueryMeta;
-  }; /** Get query key for QueryClient methods (setQueryData, getQueryData, etc.) */
-  queryKey: (args?: DeepPartial<FunctionArgs<T>>) => ConvexQueryKey<T>; /** Get query filter for QueryClient methods (invalidateQueries, removeQueries, etc.) */
-  queryFilter: (args?: DeepPartial<FunctionArgs<T>>, filters?: DistributiveOmit<QueryFilters, 'queryKey'>) => QueryFilters;
-};
-/** Reserved options controlled by infinite query factories */
-type ReservedInfiniteQueryOptions = 'queryKey' | 'queryFn' | 'staleTime' | 'refetchInterval' | 'refetchOnMount' | 'refetchOnReconnect' | 'refetchOnWindowFocus' | 'persister' | 'placeholderData';
-/** Options for infinite query - extends TanStack Query options */
-type InfiniteQueryOptsParam<T extends FunctionReference<'query'> = FunctionReference<'query'>> = {
-  /** Items per page. Optional - server uses .paginated() default if not provided. */limit?: number; /** Skip query silently when unauthenticated */
-  skipUnauth?: boolean; /** Placeholder data shown while loading (item array, not pagination result) */
-  placeholderData?: ExtractPaginatedItem<FunctionReturnType<T>>[];
-} & DistributiveOmit<UseQueryOptions<FunctionReturnType<T>, DefaultError>, ReservedInfiniteQueryOptions>;
-/** Metadata for infinite query (extends ConvexQueryMeta) */
-type ConvexInfiniteQueryMeta = ConvexQueryMeta & {
-  /** The query function name (serializable for RSC) */queryName: string; /** Query args without cursor/limit (user's filter args only) */
-  args: Record<string, unknown>; /** Items per page (optional - server uses .paginated() default) */
-  limit?: number;
-};
-/** Return type of infiniteQueryOptions - compatible with TanStack prefetch */
-type ConvexInfiniteQueryOptions<T extends FunctionReference<'query'>> = Pick<UseQueryOptions<FunctionReturnType<T>, Error, FunctionReturnType<T>, ConvexQueryKey<T>>, 'queryKey' | 'staleTime' | 'enabled'> & {
-  meta: ConvexInfiniteQueryMeta;
-  refetchInterval: false;
-  refetchOnMount: false;
-  refetchOnReconnect: false;
-  refetchOnWindowFocus: false; /** Placeholder data shown while loading (item array, not pagination result) */
-  placeholderData?: ExtractPaginatedItem<FunctionReturnType<T>>[];
-} & DistributiveOmit<UseQueryOptions<FunctionReturnType<T>, DefaultError>, ReservedInfiniteQueryOptions>;
-/** Infinite query options with attached function reference (client-only) */
-type ConvexInfiniteQueryOptionsWithRef<T extends FunctionReference<'query'>> = ConvexInfiniteQueryOptions<T> & {
-  [FUNC_REF_SYMBOL]: T;
-};
-/** Infinite query options return type */
-type InfiniteQueryOptsReturn<T extends FunctionReference<'query'>> = ConvexInfiniteQueryOptionsWithRef<T>;
-/**
- * Decorated infinite query procedure.
- * Only available on queries that have cursor/limit in their input (paginated).
- * Supports skipToken for conditional queries.
- * Args are optional when the function has no required parameters (besides cursor/limit).
- */
-type DecorateInfiniteQuery<T extends FunctionReference<'query'>> = {
-  /** Create infinite query options for useInfiniteQuery and prefetch */infiniteQueryOptions: keyof InfiniteQueryInput<FunctionArgs<T>> extends never ? (args?: EmptyObject | SkipToken, opts?: InfiniteQueryOptsParam<T>) => InfiniteQueryOptsReturn<T> : EmptyObject extends InfiniteQueryInput<FunctionArgs<T>> ? (args?: InfiniteQueryInput<FunctionArgs<T>> | SkipToken, opts?: InfiniteQueryOptsParam<T>) => InfiniteQueryOptsReturn<T> : (args: InfiniteQueryInput<FunctionArgs<T>> | SkipToken, opts?: InfiniteQueryOptsParam<T>) => InfiniteQueryOptsReturn<T>; /** Get query key for infinite query (QueryClient methods like setQueryData, getQueryData) */
-  infiniteQueryKey: (args?: DeepPartial<InfiniteQueryInput<FunctionArgs<T>>>) => ConvexQueryKey<T>; /** Function metadata from server (auth, limit, rateLimit, role, type) */
-  meta: PaginatedFnMeta;
-};
-/** Mutation variables type - undefined when no args required (allows mutateAsync() without args) */
-type MutationVariables<T extends FunctionReference<'mutation' | 'action'>> = keyof FunctionArgs<T> extends never ? void : EmptyObject extends FunctionArgs<T> ? FunctionArgs<T> | undefined : FunctionArgs<T>;
-/**
- * Decorated mutation procedure with mutationOptions and mutationKey methods.
- */
-type DecorateMutation<T extends FunctionReference<'mutation'>> = {
-  mutationOptions: (opts?: DistributiveOmit<UseMutationOptions<FunctionReturnType<T>, DefaultError, MutationVariables<T>>, ReservedMutationOptions>) => UseMutationOptions<FunctionReturnType<T>, DefaultError, MutationVariables<T>>; /** Get mutation key for QueryClient methods */
-  mutationKey: () => ConvexMutationKey;
-};
-/**
- * Decorated action procedure with queryOptions, mutationOptions, and key methods.
- * Actions can be used as one-shot queries (no subscription) or as mutations.
- * Supports skipToken for conditional queries.
- */
-type DecorateAction<T extends FunctionReference<'action'>> = {
-  /** Use action as a one-shot query (no WebSocket subscription) */queryOptions: keyof FunctionArgs<T> extends never ? (args?: EmptyObject | SkipToken, opts?: ActionQueryOptsParam<T>) => ActionQueryOptsReturn<T> : EmptyObject extends FunctionArgs<T> ? (args?: FunctionArgs<T> | SkipToken, opts?: ActionQueryOptsParam<T>) => ActionQueryOptsReturn<T> : (args: FunctionArgs<T> | SkipToken, opts?: ActionQueryOptsParam<T>) => ActionQueryOptsReturn<T>; /** Static (non-hook) action query options for event handlers and prefetching */
-  staticQueryOptions: keyof FunctionArgs<T> extends never ? (args?: EmptyObject | SkipToken, opts?: StaticQueryOptsParam) => ConvexActionOptions<T> & {
-    meta: ConvexQueryMeta;
-  } : EmptyObject extends FunctionArgs<T> ? (args?: FunctionArgs<T> | SkipToken, opts?: StaticQueryOptsParam) => ConvexActionOptions<T> & {
-    meta: ConvexQueryMeta;
-  } : (args: FunctionArgs<T> | SkipToken, opts?: StaticQueryOptsParam) => ConvexActionOptions<T> & {
-    meta: ConvexQueryMeta;
-  }; /** Use action as a mutation */
-  mutationOptions: (opts?: DistributiveOmit<UseMutationOptions<FunctionReturnType<T>, DefaultError, MutationVariables<T>>, ReservedMutationOptions>) => UseMutationOptions<FunctionReturnType<T>, DefaultError, MutationVariables<T>>; /** Get mutation key for QueryClient methods */
-  mutationKey: () => ConvexMutationKey; /** Get query key for QueryClient methods */
-  queryKey: (args?: DeepPartial<FunctionArgs<T>>) => ConvexActionKey<T>; /** Get query filter for QueryClient methods */
-  queryFilter: (args?: DeepPartial<FunctionArgs<T>>, filters?: DistributiveOmit<QueryFilters, 'queryKey'>) => QueryFilters;
-};
-/** Vanilla query - direct .query() and .watchQuery() calls without React Query */
-type VanillaQuery<T extends FunctionReference<'query'>> = {
-  query: keyof FunctionArgs<T> extends never ? (args?: EmptyObject) => Promise<FunctionReturnType<T>> : EmptyObject extends FunctionArgs<T> ? (args?: FunctionArgs<T>) => Promise<FunctionReturnType<T>> : (args: FunctionArgs<T>) => Promise<FunctionReturnType<T>>;
-  watchQuery: keyof FunctionArgs<T> extends never ? (args?: EmptyObject, opts?: WatchQueryOptions) => Watch<FunctionReturnType<T>> : EmptyObject extends FunctionArgs<T> ? (args?: FunctionArgs<T>, opts?: WatchQueryOptions) => Watch<FunctionReturnType<T>> : (args: FunctionArgs<T>, opts?: WatchQueryOptions) => Watch<FunctionReturnType<T>>;
-};
-/** Vanilla mutation - direct .mutate() call without React Query */
-type VanillaMutation<T extends FunctionReference<'mutation'>> = {
-  mutate: keyof FunctionArgs<T> extends never ? (args?: EmptyObject) => Promise<FunctionReturnType<T>> : EmptyObject extends FunctionArgs<T> ? (args?: FunctionArgs<T>) => Promise<FunctionReturnType<T>> : (args: FunctionArgs<T>) => Promise<FunctionReturnType<T>>;
-};
-/** Vanilla action - both .query() and .mutate() for direct calls */
-type VanillaAction<T extends FunctionReference<'action'>> = {
-  query: keyof FunctionArgs<T> extends never ? (args?: EmptyObject) => Promise<FunctionReturnType<T>> : EmptyObject extends FunctionArgs<T> ? (args?: FunctionArgs<T>) => Promise<FunctionReturnType<T>> : (args: FunctionArgs<T>) => Promise<FunctionReturnType<T>>;
-  mutate: keyof FunctionArgs<T> extends never ? (args?: EmptyObject) => Promise<FunctionReturnType<T>> : EmptyObject extends FunctionArgs<T> ? (args?: FunctionArgs<T>) => Promise<FunctionReturnType<T>> : (args: FunctionArgs<T>) => Promise<FunctionReturnType<T>>;
-};
-/**
- * Recursively creates vanilla client type for direct procedural calls.
- * Similar to CRPCClient but for imperative usage outside React Query.
- *
- * @example
- * ```ts
- * const client = useCRPCClient();
- * await client.user.get.query({ id });
- * await client.user.update.mutate({ id, name: 'test' });
- * ```
- */
-type VanillaCRPCClient<TApi> = { [K in keyof TApi as K extends string ? K extends `_${string}` ? never : K : K]: TApi[K] extends FunctionReference<'query'> ? VanillaQuery<TApi[K]> : TApi[K] extends FunctionReference<'mutation'> ? VanillaMutation<TApi[K]> : TApi[K] extends FunctionReference<'action'> ? VanillaAction<TApi[K]> : TApi[K] extends Record<string, unknown> ? VanillaCRPCClient<TApi[K]> : never };
-/**
- * Recursively decorates all procedures in a Convex API object.
- *
- * - Queries get `queryOptions(args, opts?)`
- * - Paginated queries also get `infiniteQueryOptions(args, opts)`
- * - Mutations get `mutationOptions(opts?)`
- * - Actions get `mutationOptions(opts?)`
- * - Nested objects are recursively decorated
- *
- * @example
- * ```ts
- * type Client = CRPCClient<typeof api>;
- * // Client.user.get.queryOptions({ id }) -> QueryOptions
- * // Client.posts.list.infiniteQueryOptions({ userId }, { initialNumItems: 20 }) -> InfiniteQueryOptions
- * // Client.user.update.mutationOptions() -> MutationOptions
- * ```
- */
-/** Check if a type has cursor key (pagination detection) */
-type IsPaginated<T> = 'cursor' extends keyof T ? true : false;
-type CRPCClient<TApi> = { [K in keyof TApi as K extends string ? K extends `_${string}` ? never : K : K]: TApi[K] extends FunctionReference<'query'> ? IsPaginated<FunctionArgs<TApi[K]>> extends true ? DecorateQuery<TApi[K]> & DecorateInfiniteQuery<TApi[K]> : DecorateQuery<TApi[K]> : TApi[K] extends FunctionReference<'mutation'> ? DecorateMutation<TApi[K]> : TApi[K] extends FunctionReference<'action'> ? DecorateAction<TApi[K]> : TApi[K] extends Record<string, unknown> ? CRPCClient<TApi[K]> : never };
-//#endregion
-export { PaginatedFnMeta as C, VanillaMutation as D, VanillaCRPCClient as E, VanillaQuery as O, Meta as S, VanillaAction as T, ExtractPaginatedItem as _, ConvexInfiniteQueryMeta as a, InfiniteQueryInput as b, ConvexMutationKey as c, ConvexQueryMeta as d, ConvexQueryOptions as f, DecorateQuery as g, DecorateMutation as h, ConvexActionOptions as i, ConvexQueryHookOptions as l, DecorateInfiniteQuery as m, CRPCClient as n, ConvexInfiniteQueryOptions as o, DecorateAction as p, ConvexActionKey as r, ConvexInfiniteQueryOptionsWithRef as s, AuthType as t, ConvexQueryKey as u, FUNC_REF_SYMBOL as v, PaginationOpts as w, InfiniteQueryOptsParam as x, FnMeta as y };