kitcn 0.0.1 → 0.12.0

package/dist/transformer-DtDhR3Lc.js

@@ -0,0 +1,194 @@
+//#region src/crpc/transformer.ts
+const isPlainObject = (value) => {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+};
+const CODEC_MARKER_KEY = "__crpc";
+const CODEC_MARKER_VALUE = 1;
+const CODEC_TAG_KEY = "t";
+const CODEC_VALUE_KEY = "v";
+const hasOnlyCodecPayloadKeys = (value) => {
+	let keyCount = 0;
+	for (const key in value) {
+		if (!Object.hasOwn(value, key)) continue;
+		keyCount += 1;
+		if (key !== CODEC_MARKER_KEY && key !== CODEC_TAG_KEY && key !== CODEC_VALUE_KEY) return false;
+		if (keyCount > 3) return false;
+	}
+	return keyCount === 3;
+};
+/**
+* Date wire tag (Convex-style reserved key).
+*/
+const DATE_CODEC_TAG = "$date";
+/**
+* Built-in Date codec.
+*/
+const dateWireCodec = {
+	tag: DATE_CODEC_TAG,
+	isType: (value) => value instanceof Date,
+	encode: (value) => value.getTime(),
+	decode: (value) => {
+		if (typeof value !== "number") return value;
+		return new Date(value);
+	}
+};
+/**
+* Build a recursive tagged transformer from codecs.
+*/
+const createTaggedTransformer = (codecs) => {
+	const codecByTag = /* @__PURE__ */ new Map();
+	for (const codec of codecs) {
+		if (!codec.tag.startsWith("$")) throw new Error(`Invalid wire codec tag '${codec.tag}'. Tags must start with '$'.`);
+		if (codecByTag.has(codec.tag)) throw new Error(`Duplicate wire codec tag '${codec.tag}'.`);
+		codecByTag.set(codec.tag, codec);
+	}
+	const serialize = (value) => {
+		for (const codec of codecs) if (codec.isType(value)) return {
+			[CODEC_MARKER_KEY]: CODEC_MARKER_VALUE,
+			[CODEC_TAG_KEY]: codec.tag,
+			[CODEC_VALUE_KEY]: serialize(codec.encode(value))
+		};
+		if (Array.isArray(value)) {
+			let result;
+			for (let index = 0; index < value.length; index += 1) {
+				const item = value[index];
+				const serialized = serialize(item);
+				if (serialized !== item) {
+					if (!result) result = value.slice();
+					result[index] = serialized;
+				}
+			}
+			return result ?? value;
+		}
+		if (isPlainObject(value)) {
+			let result;
+			for (const key in value) {
+				if (!Object.hasOwn(value, key)) continue;
+				const nested = value[key];
+				const serialized = serialize(nested);
+				if (serialized !== nested) {
+					if (!result) result = { ...value };
+					result[key] = serialized;
+				}
+			}
+			return result ?? value;
+		}
+		return value;
+	};
+	const deserialize = (value) => {
+		if (Array.isArray(value)) {
+			let result;
+			for (let index = 0; index < value.length; index += 1) {
+				const item = value[index];
+				const deserialized = deserialize(item);
+				if (deserialized !== item) {
+					if (!result) result = value.slice();
+					result[index] = deserialized;
+				}
+			}
+			return result ?? value;
+		}
+		if (isPlainObject(value)) {
+			const marker = value[CODEC_MARKER_KEY];
+			const tag = value[CODEC_TAG_KEY];
+			if (marker === CODEC_MARKER_VALUE && typeof tag === "string" && CODEC_VALUE_KEY in value && hasOnlyCodecPayloadKeys(value)) {
+				const codec = codecByTag.get(tag);
+				if (codec) return codec.decode(deserialize(value[CODEC_VALUE_KEY]));
+			}
+			let result;
+			for (const key in value) {
+				if (!Object.hasOwn(value, key)) continue;
+				const nested = value[key];
+				const deserialized = deserialize(nested);
+				if (deserialized !== nested) {
+					if (!result) result = { ...value };
+					result[key] = deserialized;
+				}
+			}
+			return result ?? value;
+		}
+		return value;
+	};
+	return {
+		serialize,
+		deserialize
+	};
+};
+/**
+* Default cRPC transformer (Date-enabled).
+*/
+const defaultCRPCTransformer = createTaggedTransformer([dateWireCodec]);
+const DEFAULT_COMBINED_TRANSFORMER = {
+	input: defaultCRPCTransformer,
+	output: defaultCRPCTransformer
+};
+const IDENTITY_TRANSFORMER = {
+	input: {
+		serialize: (value) => value,
+		deserialize: (value) => value
+	},
+	output: {
+		serialize: (value) => value,
+		deserialize: (value) => value
+	}
+};
+/**
+* Normalize transformer config to split input/output shape.
+*/
+const normalizeCustomTransformer = (transformer) => {
+	if (!transformer) return;
+	if ("input" in transformer && "output" in transformer) return transformer;
+	return {
+		input: transformer,
+		output: transformer
+	};
+};
+/**
+* Compose user transformer with default Date transformer.
+*
+* Date transformer is always active:
+* - serialize: user -> default(Date)
+* - deserialize: default(Date) -> user
+*/
+const composeWithDefault = (transformer) => {
+	if (!transformer) return defaultCRPCTransformer;
+	return {
+		serialize: (value) => defaultCRPCTransformer.serialize(transformer.serialize(value)),
+		deserialize: (value) => transformer.deserialize(defaultCRPCTransformer.deserialize(value))
+	};
+};
+const transformerCache = /* @__PURE__ */ new WeakMap();
+/**
+* Normalize transformer config to split input/output shape.
+* User transformers are additive and always composed with default Date handling.
+*/
+const getTransformer = (transformer) => {
+	if (!transformer) return DEFAULT_COMBINED_TRANSFORMER;
+	const cacheKey = transformer;
+	const cached = transformerCache.get(cacheKey);
+	if (cached) return cached;
+	const custom = normalizeCustomTransformer(transformer);
+	const resolved = {
+		input: composeWithDefault(custom?.input),
+		output: composeWithDefault(custom?.output)
+	};
+	transformerCache.set(cacheKey, resolved);
+	return resolved;
+};
+/**
+* Encode request payloads (input direction).
+*/
+const encodeWire = (value, transformer) => getTransformer(transformer).input.serialize(value);
+/**
+* Decode response payloads (output direction).
+*/
+const decodeWire = (value, transformer) => getTransformer(transformer).output.deserialize(value);
+/**
+* Exposed identity transformer for advanced composition.
+*/
+const identityTransformer = IDENTITY_TRANSFORMER;
+
+//#endregion
+export { defaultCRPCTransformer as a, identityTransformer as c, decodeWire as i, createTaggedTransformer as n, encodeWire as o, dateWireCodec as r, getTransformer as s, DATE_CODEC_TAG as t };

package/dist/types-BTb_4BaU.d.ts

@@ -0,0 +1,42 @@
+//#region src/internal/types.d.ts
+/**
+ * Filter object type to only known keys from reference type.
+ * Pattern from Drizzle ORM: drizzle-orm/src/utils.ts:151-156
+ *
+ * Prevents extra properties from widening inferred types.
+ *
+ * @example
+ * type Config = { name: string; age: number };
+ * type Input = { name: string; age: number; extra: boolean };
+ * type Filtered = KnownKeysOnly<Input, Config>; // { name: string; age: number }
+ * @public
+ */
+type KnownKeysOnly<T, K> = { [P in keyof T]: P extends keyof K ? T[P] : never };
+/**
+ * Narrow a type to an expected shape without losing inference.
+ * Pattern from Drizzle ORM: drizzle-orm/src/utils.ts
+ * @public
+ */
+type Assume<T, U> = T extends U ? T : U;
+/**
+ * Extract return type if function, otherwise use the value type.
+ * Pattern from Drizzle ORM: drizzle-orm/src/relations.ts
+ * @public
+ */
+type ReturnTypeOrValue<T> = T extends ((...args: any[]) => infer R) ? R : T;
+/**
+ * Simplify complex type intersections for better IDE display.
+ * Pattern from Drizzle ORM: The & {} intersection "seals" the type to prevent
+ * distributive conditional behavior that can cause union widening.
+ * @see https://github.com/drizzle-team/drizzle-orm/blob/main/drizzle-orm/src/utils.ts#L144-L149
+ */
+type Simplify<TType> = TType extends any[] | Date ? TType : { [K in keyof TType]: TType[K] } & {};
+/**
+ * Omit keys without removing a potential union.
+ * Unlike standard Omit, this preserves union types.
+ */
+type DistributiveOmit<TObj, TKey extends keyof any> = TObj extends any ? Omit<TObj, TKey> : never;
+/** Makes the object recursively optional */
+type DeepPartial<TObject> = TObject extends object ? { [P in keyof TObject]?: DeepPartial<TObject[P]> } : TObject;
+//#endregion
+export { ReturnTypeOrValue as a, KnownKeysOnly as i, DeepPartial as n, Simplify as o, DistributiveOmit as r, Assume as t };

package/dist/types-BiJE7qxR.d.ts

@@ -0,0 +1,4 @@
+//#region src/auth/types.d.ts
+type GetAuth<Ctx = unknown, Auth = unknown> = (ctx: Ctx) => Auth;
+//#endregion
+export { GetAuth as t };

package/dist/types-DEJpkIhw.d.ts

@@ -0,0 +1,88 @@
+import { z } from "zod";
+
+//#region src/server/types.d.ts
+/** Marker for unset values - branded type to distinguish "not set" from actual types */
+type UnsetMarker = {
+  readonly __brand: 'UnsetMarker';
+};
+/** Marker to enforce middleware returns next() result */
+type MiddlewareMarker = {
+  readonly __brand: 'MiddlewareMarker';
+};
+/** Flatten intersection types for better IDE display */
+type Simplify<T> = { [K in keyof T]: T[K] } & {};
+/**
+ * Merge context types - preserves existing properties while adding new ones
+ * - If TWith is UnsetMarker, returns TType unchanged
+ * - If TType is UnsetMarker, returns TWith (no __brand leakage)
+ * - Otherwise, merges with TWith properties taking precedence
+ */
+type Overwrite<TType, TWith> = TWith extends UnsetMarker ? TType : TType extends UnsetMarker ? TWith : TWith extends object ? Simplify<Omit<TType, keyof TWith> & TWith> : TType;
+/** Resolve type only if it's not UnsetMarker */
+type ResolveIfSet<T, TFallback> = T extends UnsetMarker ? TFallback : T;
+/**
+ * Merge two ZodObject types into a single ZodObject with combined shape
+ * Used for chained .input() calls
+ */
+type MergeZodObjects<T, U> = T extends z.ZodObject<infer A> ? U extends z.ZodObject<infer B> ? z.ZodObject<Simplify<A & B>> : T : T;
+/**
+ * Intersect two types, handling UnsetMarker and ZodObject merging
+ * - If TType is UnsetMarker, returns TWith
+ * - If TWith is UnsetMarker, returns TType
+ * - If both are ZodObjects, merges their shapes into a new ZodObject
+ * - Otherwise, returns the intersection simplified
+ */
+type IntersectIfDefined<TType, TWith> = TType extends UnsetMarker ? TWith : TWith extends UnsetMarker ? TType : MergeZodObjects<TType, TWith>;
+/** Result wrapper that enforces middleware returns next() */
+type MiddlewareResult<TContext> = {
+  readonly marker: MiddlewareMarker;
+  ctx: TContext;
+};
+/** Function to get raw input before validation */
+type GetRawInputFn = () => Promise<unknown>;
+/**
+ * Next function overloads - key to automatic context and input inference
+ * Matches tRPC's pattern: can modify context, input, or both
+ */
+type MiddlewareNext<TContextOverridesIn> = {
+  /** Continue without modification - passes through existing overrides */(): Promise<MiddlewareResult<TContextOverridesIn>>; /** Continue with modified context and/or input */
+  <$ContextOverride>(opts: {
+    ctx?: $ContextOverride;
+    input?: unknown;
+  }): Promise<MiddlewareResult<$ContextOverride>>;
+};
+/**
+ * Middleware function signature with input access (tRPC-compatible)
+ *
+ * @typeParam TContext - Base context type
+ * @typeParam TMeta - Procedure metadata type
+ * @typeParam TContextOverridesIn - Context overrides from previous middleware
+ * @typeParam $ContextOverridesOut - Context overrides this middleware adds (inferred from next())
+ * @typeParam TInputOut - Parsed input type (unknown if before .input(), typed if after)
+ */
+type MiddlewareFunction<TContext, TMeta, TContextOverridesIn, $ContextOverridesOut, TInputOut = unknown> = (opts: {
+  ctx: Simplify<Overwrite<TContext, TContextOverridesIn>>;
+  meta: TMeta;
+  input: TInputOut;
+  getRawInput: GetRawInputFn;
+  next: MiddlewareNext<TContextOverridesIn>;
+}) => Promise<MiddlewareResult<$ContextOverridesOut>>;
+/** Stored middleware with type info erased for runtime */
+type AnyMiddleware = MiddlewareFunction<any, any, any, any, any>;
+/**
+ * Middleware builder for creating reusable, composable middleware chains
+ * Similar to tRPC's MiddlewareBuilder
+ *
+ * @typeParam TContext - Base context type
+ * @typeParam TMeta - Procedure metadata type
+ * @typeParam $ContextOverridesOut - Accumulated context overrides
+ * @typeParam TInputOut - Input type this middleware chain expects
+ */
+type MiddlewareBuilder<TContext, TMeta, $ContextOverridesOut, TInputOut = unknown> = {
+  /** Internal array of middleware functions */_middlewares: AnyMiddleware[]; /** Chain another middleware to this builder */
+  pipe<$NewContextOverrides>(fn: MiddlewareFunction<TContext, TMeta, $ContextOverridesOut, $NewContextOverrides, TInputOut>): MiddlewareBuilder<TContext, TMeta, Overwrite<$ContextOverridesOut, $NewContextOverrides>, TInputOut>;
+};
+/** Type-erased middleware builder for runtime */
+type AnyMiddlewareBuilder = MiddlewareBuilder<any, any, any, any>;
+//#endregion
+export { MergeZodObjects as a, MiddlewareMarker as c, Overwrite as d, ResolveIfSet as f, IntersectIfDefined as i, MiddlewareNext as l, UnsetMarker as m, AnyMiddlewareBuilder as n, MiddlewareBuilder as o, Simplify as p, GetRawInputFn as r, MiddlewareFunction as s, AnyMiddleware as t, MiddlewareResult as u };

package/dist/types-HhO_R6pd.d.ts

@@ -0,0 +1,213 @@
+import { O as CombinedDataTransformer, n as HttpClientError } from "./http-types-DqJubRPJ.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 };