kitcn 0.0.1 → 0.12.1

package/dist/context-utils-HPC5nXzx.d.ts

@@ -0,0 +1,17 @@
+import { GenericActionCtx, GenericDataModel, GenericMutationCtx, GenericQueryCtx } from "convex/server";
+
+//#region src/server/context-utils.d.ts
+type GenericCtx<DataModel extends GenericDataModel = GenericDataModel> = GenericQueryCtx<DataModel> | GenericMutationCtx<DataModel> | GenericActionCtx<DataModel>;
+type RunMutationCtx<DataModel extends GenericDataModel> = (GenericMutationCtx<DataModel> | GenericActionCtx<DataModel>) & {
+  runMutation: GenericMutationCtx<DataModel>['runMutation'];
+};
+declare const isQueryCtx: <DataModel extends GenericDataModel>(ctx: GenericCtx<DataModel>) => ctx is GenericQueryCtx<DataModel>;
+declare const isMutationCtx: <DataModel extends GenericDataModel>(ctx: GenericCtx<DataModel>) => ctx is GenericMutationCtx<DataModel>;
+declare const isActionCtx: <DataModel extends GenericDataModel>(ctx: GenericCtx<DataModel>) => ctx is GenericActionCtx<DataModel>;
+declare const isRunMutationCtx: <DataModel extends GenericDataModel>(ctx: GenericCtx<DataModel>) => ctx is RunMutationCtx<DataModel>;
+declare const requireQueryCtx: <DataModel extends GenericDataModel>(ctx: GenericCtx<DataModel>) => GenericQueryCtx<DataModel>;
+declare const requireMutationCtx: <DataModel extends GenericDataModel>(ctx: GenericCtx<DataModel>) => GenericMutationCtx<DataModel>;
+declare const requireActionCtx: <DataModel extends GenericDataModel>(ctx: GenericCtx<DataModel>) => GenericActionCtx<DataModel>;
+declare const requireRunMutationCtx: <DataModel extends GenericDataModel>(ctx: GenericCtx<DataModel>) => RunMutationCtx<DataModel>;
+//#endregion
+export { isQueryCtx as a, requireMutationCtx as c, isMutationCtx as i, requireQueryCtx as l, RunMutationCtx as n, isRunMutationCtx as o, isActionCtx as r, requireActionCtx as s, GenericCtx as t, requireRunMutationCtx as u };

package/dist/create-schema-odyF4kCy.js

@@ -0,0 +1,156 @@
+//#region src/auth/create-schema.ts
+const indexFields = {
+	account: [
+		"accountId",
+		["accountId", "providerId"],
+		["providerId", "userId"]
+	],
+	oauthConsent: [["clientId", "userId"]],
+	passkey: ["credentialID"],
+	ratelimit: ["key"],
+	rateLimit: ["key"],
+	session: ["expiresAt", ["expiresAt", "userId"]],
+	user: [["email", "name"], "name"],
+	verification: ["expiresAt", "identifier"]
+};
+const cloneTables = (tables) => Object.fromEntries(Object.entries(tables).map(([key, table]) => [key, {
+	...table,
+	fields: { ...table.fields }
+}]));
+const ensureField = (tables, tableKey, fieldKey, fieldPatch) => {
+	const table = tables[tableKey];
+	if (!table) return;
+	const existingField = table.fields[fieldKey];
+	if (!existingField) {
+		table.fields[fieldKey] = fieldPatch;
+		return;
+	}
+	table.fields[fieldKey] = {
+		...fieldPatch,
+		...existingField,
+		references: existingField.references ?? fieldPatch.references
+	};
+};
+const augmentBetterAuthTables = (sourceTables) => {
+	const tables = cloneTables(sourceTables);
+	if (tables.organization && tables.user) {
+		const organizationReference = {
+			field: "id",
+			model: "organization"
+		};
+		ensureField(tables, "user", "lastActiveOrganizationId", {
+			references: organizationReference,
+			required: false,
+			type: "string"
+		});
+		ensureField(tables, "user", "personalOrganizationId", {
+			references: organizationReference,
+			required: false,
+			type: "string"
+		});
+		ensureField(tables, "session", "activeOrganizationId", {
+			references: organizationReference,
+			required: false,
+			type: "string"
+		});
+	}
+	if (tables.team) {
+		const teamReference = {
+			field: "id",
+			model: "team"
+		};
+		ensureField(tables, "session", "activeTeamId", {
+			references: teamReference,
+			required: false,
+			type: "string"
+		});
+		ensureField(tables, "invitation", "teamId", {
+			references: teamReference,
+			required: false,
+			type: "string"
+		});
+	}
+	return tables;
+};
+const specialFields = (tables) => Object.fromEntries(Object.entries(tables).map(([key, table]) => {
+	return [key, Object.fromEntries(Object.entries(table.fields).map(([fieldKey, field]) => [field.fieldName ?? fieldKey, {
+		...field.sortable ? { sortable: true } : {},
+		...field.unique ? { unique: true } : {},
+		...field.references ? { references: field.references } : {}
+	}]).filter(([_key, value]) => typeof value === "object" ? Object.keys(value).length > 0 : true))];
+}).filter(([_key, value]) => typeof value === "object" ? Object.keys(value).length > 0 : true));
+const mergedIndexFields = (tables) => Object.fromEntries(Object.entries(tables).map(([key, table]) => {
+	const resolveIndexField = (fieldKey) => {
+		const field = table.fields[fieldKey];
+		return field ? field.fieldName ?? fieldKey : null;
+	};
+	const manualIndexes = indexFields[key]?.reduce((indexes, index) => {
+		if (typeof index === "string") {
+			const resolved = resolveIndexField(index);
+			if (resolved) indexes.push(resolved);
+			return indexes;
+		}
+		const resolved = index.map((fieldKey) => resolveIndexField(fieldKey)).filter((fieldName) => fieldName !== null);
+		if (resolved.length === index.length) indexes.push(resolved);
+		return indexes;
+	}, []) || [];
+	const specialFieldIndexes = Object.keys(specialFields(tables)[key] || {}).filter((index) => !manualIndexes.some((m) => Array.isArray(m) ? m[0] === index : m === index));
+	return [key, manualIndexes.concat(specialFieldIndexes)];
+}));
+const createSchema = async ({ exportName = "tables", file, regenerateCommand, tables }) => {
+	const path = await import(Buffer.from("cGF0aA==", "base64").toString());
+	if (path.basename(path.resolve(process.cwd(), file ?? "")) === "convex") throw new Error("Better Auth schema must be generated in the Better Auth component directory.");
+	tables = augmentBetterAuthTables(tables);
+	let code = `// This file is auto-generated. Do not edit this file manually.
+// To regenerate the schema, run:
+// \`${regenerateCommand ?? `npx @better-auth/cli generate --output ${file} -y`}\`
+
+import { defineSchema, defineTable } from "convex/server";
+import { v } from "convex/values";
+
+export const ${exportName} = {
+`;
+	for (const [tableKey, table] of Object.entries(tables)) {
+		const modelName = table.modelName;
+		const fields = Object.fromEntries(Object.entries(table.fields).filter(([key]) => key !== "id"));
+		function getType(_name, field) {
+			const type = field.type;
+			return {
+				boolean: "v.boolean()",
+				date: "v.number()",
+				json: "v.string()",
+				number: "v.number()",
+				"number[]": "v.array(v.number())",
+				string: "v.string()",
+				"string[]": "v.array(v.string())"
+			}[type];
+		}
+		const indexes = mergedIndexFields(tables)[tableKey]?.map((index) => {
+			const indexArray = Array.isArray(index) ? index.sort() : [index];
+			return `.index("${indexArray.join("_")}", ${JSON.stringify(indexArray)})`;
+		}) || [];
+		const schema = `${modelName}: defineTable({
+${Object.keys(fields).map((field) => {
+			const attr = fields[field];
+			const type = getType(field, attr);
+			const optional = (fieldSchema) => attr.required ? fieldSchema : `v.optional(v.union(v.null(), ${fieldSchema}))`;
+			return `    ${attr.fieldName ?? field}: ${optional(type)},`;
+		}).join("\n")}
+  })${indexes.length > 0 ? `\n    ${indexes.join("\n    ")}` : ""},\n`;
+		code += `  ${schema}`;
+	}
+	code += `};
+
+const schema = defineSchema(${exportName});
+
+export default schema;
+`;
+	return {
+		code,
+		overwrite: true,
+		path: file ?? "./schema.ts"
+	};
+};
+
+//#endregion
+export { augmentBetterAuthTables, createSchema, indexFields };

package/dist/create-schema-orm-DOyiNDCx.js

@@ -0,0 +1,246 @@
+import { augmentBetterAuthTables, indexFields } from "./create-schema-odyF4kCy.js";
+
+//#region src/auth/create-schema-orm.ts
+const specialFields = (tables) => Object.fromEntries(Object.entries(tables).map(([key, table]) => {
+	return [key, Object.fromEntries(Object.entries(table.fields).map(([fieldKey, field]) => [field.fieldName ?? fieldKey, {
+		...field.sortable ? { sortable: true } : {},
+		...field.unique ? { unique: true } : {},
+		...field.references ? { references: field.references } : {}
+	}]).filter(([_key, value]) => typeof value === "object" ? Object.keys(value).length > 0 : true))];
+}).filter(([_key, value]) => typeof value === "object" ? Object.keys(value).length > 0 : true));
+const mergedIndexFields = (tables) => Object.fromEntries(Object.entries(tables).map(([key, table]) => {
+	const tableSpecialFields = specialFields(tables)[key] || {};
+	const resolveIndexField = (fieldKey) => {
+		const field = table.fields[fieldKey];
+		return field ? field.fieldName ?? fieldKey : null;
+	};
+	const manualIndexes = indexFields[key]?.reduce((indexes, index) => {
+		if (typeof index === "string") {
+			const resolved = resolveIndexField(index);
+			if (resolved) indexes.push(resolved);
+			return indexes;
+		}
+		const resolved = index.map((fieldKey) => resolveIndexField(fieldKey)).filter((fieldName) => fieldName !== null);
+		if (resolved.length === index.length) indexes.push(resolved);
+		return indexes;
+	}, []) || [];
+	const specialFieldIndexes = Object.entries(tableSpecialFields).filter(([, fieldMeta]) => fieldMeta.unique !== true).map(([fieldName]) => fieldName).filter((index) => !manualIndexes.some((m) => Array.isArray(m) ? m[0] === index : m === index));
+	return [key, manualIndexes.concat(specialFieldIndexes)];
+}));
+const VALID_IDENTIFIER_REGEX = /^[$A-Z_][0-9A-Z_$]*$/i;
+const LEADING_DIGIT_REGEX = /^[0-9]/;
+const PLURALIZE_ES_SUFFIX_REGEX = /(?:s|x|z|ch|sh)$/i;
+const PLURALIZE_IES_SUFFIX_REGEX = /[^aeiou]y$/i;
+const TABLE_IDENTIFIER_SUFFIX_REGEX = /(?:Table|_table)$/i;
+const renderObjectKey = (value) => VALID_IDENTIFIER_REGEX.test(value) ? value : JSON.stringify(value);
+const renderPropertyAccess = (objectName, propertyName) => VALID_IDENTIFIER_REGEX.test(propertyName) ? `${objectName}.${propertyName}` : `${objectName}[${JSON.stringify(propertyName)}]`;
+const toIdentifier = (value) => {
+	const normalized = value.replace(/[^a-zA-Z0-9_$]/g, "_");
+	if (!normalized) return "_table";
+	if (LEADING_DIGIT_REGEX.test(normalized)) return `_${normalized}`;
+	return normalized;
+};
+const toTableIdentifier = (value) => {
+	const identifier = toIdentifier(value);
+	return TABLE_IDENTIFIER_SUFFIX_REGEX.test(identifier) ? identifier : `${identifier}Table`;
+};
+const getTableEntries = (tables) => {
+	const usedNames = /* @__PURE__ */ new Map();
+	return Object.entries(tables).map(([key, table]) => {
+		const modelName = table.modelName;
+		const baseName = toTableIdentifier(modelName);
+		const count = usedNames.get(baseName) ?? 0;
+		usedNames.set(baseName, count + 1);
+		return {
+			key,
+			modelName,
+			table,
+			varName: count === 0 ? baseName : `${baseName}_${count + 1}`
+		};
+	});
+};
+const findTableEntryByModel = (entries, tables, model) => entries.find((entry) => entry.modelName === model) ?? entries.find((entry) => entry.key === model) ?? entries.find((entry) => tables[entry.key]?.modelName === model);
+const getReferencedFieldName = (tables, entries, model, field) => {
+	if (field === "id") return "id";
+	const entry = findTableEntryByModel(entries, tables, model);
+	if (!entry) return field;
+	return entry.table.fields[field]?.fieldName ?? field;
+};
+const stripIdSuffix = (value) => value.endsWith("Id") && value.length > 2 ? value.slice(0, -2) : value;
+const capitalize = (value) => value ? `${value.slice(0, 1).toUpperCase()}${value.slice(1)}` : value;
+const pluralize = (value) => {
+	if (PLURALIZE_ES_SUFFIX_REGEX.test(value)) return `${value}es`;
+	if (PLURALIZE_IES_SUFFIX_REGEX.test(value)) return `${value.slice(0, -1)}ies`;
+	return `${value}s`;
+};
+const buildRelationEntries = (tables, entries) => {
+	const rawRelations = entries.flatMap((source) => Object.entries(source.table.fields).map(([fieldKey, field]) => {
+		const attr = field;
+		if (!attr.references) return null;
+		const target = findTableEntryByModel(entries, tables, attr.references.model) ?? null;
+		if (!target) return null;
+		return {
+			source,
+			fieldKey,
+			sourceFieldName: attr.fieldName ?? fieldKey,
+			target,
+			targetFieldName: getReferencedFieldName(tables, entries, attr.references.model, attr.references.field)
+		};
+	}).filter((value) => value !== null));
+	const pairCounts = /* @__PURE__ */ new Map();
+	for (const relation of rawRelations) {
+		const key = `${relation.source.modelName}->${relation.target.modelName}`;
+		pairCounts.set(key, (pairCounts.get(key) ?? 0) + 1);
+	}
+	return rawRelations.map((relation) => {
+		const pairKey = `${relation.source.modelName}->${relation.target.modelName}`;
+		const needsAlias = (pairCounts.get(pairKey) ?? 0) > 1;
+		const oneName = toIdentifier(stripIdSuffix(relation.fieldKey) || relation.target.modelName);
+		return {
+			alias: needsAlias ? oneName : void 0,
+			manyName: toIdentifier(needsAlias ? `${pluralize(relation.source.modelName)}As${capitalize(oneName)}` : pluralize(relation.source.modelName)),
+			oneName,
+			source: relation.source,
+			sourceFieldName: relation.sourceFieldName,
+			target: relation.target,
+			targetFieldName: relation.targetFieldName
+		};
+	});
+};
+const getTypeExpression = (field, state) => {
+	const type = field.type;
+	if (Array.isArray(type)) {
+		state.ormImports.add("textEnum");
+		return `textEnum(${`[${type.map((value) => JSON.stringify(value)).join(", ")}]`})`;
+	}
+	switch (type) {
+		case "boolean":
+			state.ormImports.add("boolean");
+			return "boolean()";
+		case "date":
+			state.ormImports.add("timestamp");
+			return "timestamp()";
+		case "json":
+			state.ormImports.add("text");
+			return "text()";
+		case "number":
+			if (field.bigint) {
+				state.ormImports.add("bigint");
+				return "bigint()";
+			}
+			state.ormImports.add("integer");
+			return "integer()";
+		case "number[]":
+			state.ormImports.add("arrayOf");
+			state.ormImports.add("integer");
+			return "arrayOf(integer().notNull())";
+		case "string":
+			state.ormImports.add("text");
+			return "text()";
+		case "string[]":
+			state.ormImports.add("arrayOf");
+			state.ormImports.add("text");
+			return "arrayOf(text().notNull())";
+		default: throw new Error(`Unsupported Better Auth field type: ${String(type)}`);
+	}
+};
+const createSchemaOrm = async ({ file, regenerateCommand, tables }) => {
+	return renderSchemaOrmFile({
+		file,
+		mode: "schema",
+		regenerateCommand,
+		tables
+	});
+};
+const renderSchemaOrmFile = async ({ extensionKey, exportName, file, mode, regenerateCommand, tables }) => {
+	const path = await import(Buffer.from("cGF0aA==", "base64").toString());
+	if (path.basename(path.resolve(process.cwd(), file ?? "")) === "convex") throw new Error("Better Auth schema must be generated in the Better Auth component directory.");
+	tables = augmentBetterAuthTables(tables);
+	const entries = getTableEntries(tables);
+	const relationEntries = buildRelationEntries(tables, entries);
+	const state = { ormImports: new Set(["convexTable", mode === "extension" ? "defineSchemaExtension" : "defineSchema"]) };
+	const tableBlocks = [];
+	for (const entry of entries) {
+		const fieldLines = Object.entries(entry.table.fields).filter(([fieldKey]) => fieldKey !== "id").map(([fieldKey, field]) => {
+			const attr = field;
+			const key = renderObjectKey(attr.fieldName ?? fieldKey);
+			let expression = getTypeExpression(attr, state);
+			if (attr.required) expression += ".notNull()";
+			if (attr.unique) expression += ".unique()";
+			if (attr.references) {
+				const referencedEntry = findTableEntryByModel(entries, tables, attr.references.model) ?? { varName: toIdentifier(attr.references.model) };
+				const targetField = getReferencedFieldName(tables, entries, attr.references.model, attr.references.field);
+				expression += `.references(() => ${renderPropertyAccess(referencedEntry.varName, targetField)})`;
+			}
+			return `    ${key}: ${expression},`;
+		});
+		const indexes = mergedIndexFields(tables)[entry.key]?.map((indexSpec) => {
+			const indexArray = Array.isArray(indexSpec) ? [...indexSpec].sort() : [indexSpec];
+			const indexName = indexArray.join("_");
+			state.ormImports.add("index");
+			const fieldsCall = indexArray.map((fieldName) => renderPropertyAccess(entry.varName, fieldName)).join(", ");
+			return `index(${JSON.stringify(indexName)}).on(${fieldsCall})`;
+		}) || [];
+		const extraConfig = indexes.length > 0 ? `,\n  (${entry.varName}) => [\n    ${indexes.join(",\n    ")},\n  ]` : "";
+		tableBlocks.push(`export const ${entry.varName} = convexTable(\n  ${JSON.stringify(entry.modelName)},\n  {\n${fieldLines.join("\n")}\n  }${extraConfig}\n);`);
+	}
+	const imports = `import {\n  ${Array.from(state.ormImports).sort().join(",\n  ")},\n} from "kitcn/orm";`;
+	const tableObject = `{
+${entries.map((entry) => {
+		if (renderObjectKey(entry.modelName) === entry.varName) return `  ${entry.varName},`;
+		return `  ${renderObjectKey(entry.modelName)}: ${entry.varName},`;
+	}).join("\n")}
+}`;
+	const relationBlocksByTable = /* @__PURE__ */ new Map();
+	for (const relation of relationEntries) {
+		const sourceLines = [
+			`    ${renderObjectKey(relation.oneName)}: ${renderPropertyAccess("r.one", relation.target.modelName)}({`,
+			`      from: ${renderPropertyAccess(renderPropertyAccess("r", relation.source.modelName), relation.sourceFieldName)},`,
+			`      to: ${renderPropertyAccess(renderPropertyAccess("r", relation.target.modelName), relation.targetFieldName)},`,
+			...relation.alias ? [`      alias: ${JSON.stringify(relation.alias)},`] : [],
+			"    }),"
+		];
+		relationBlocksByTable.set(relation.source.modelName, [...relationBlocksByTable.get(relation.source.modelName) ?? [], sourceLines.join("\n")]);
+		const targetLines = [
+			`    ${renderObjectKey(relation.manyName)}: ${renderPropertyAccess("r.many", relation.source.modelName)}({`,
+			`      from: ${renderPropertyAccess(renderPropertyAccess("r", relation.target.modelName), relation.targetFieldName)},`,
+			`      to: ${renderPropertyAccess(renderPropertyAccess("r", relation.source.modelName), relation.sourceFieldName)},`,
+			...relation.alias ? [`      alias: ${JSON.stringify(relation.alias)},`] : [],
+			"    }),"
+		];
+		relationBlocksByTable.set(relation.target.modelName, [...relationBlocksByTable.get(relation.target.modelName) ?? [], targetLines.join("\n")]);
+	}
+	const relationObjectEntries = entries.map((entry) => {
+		const relationBlocks = relationBlocksByTable.get(entry.modelName);
+		if (!relationBlocks || relationBlocks.length === 0) return null;
+		return `  ${renderObjectKey(entry.modelName)}: {\n${relationBlocks.join("\n")}\n  },`;
+	}).filter((value) => value !== null);
+	const relationChain = relationObjectEntries.length > 0 ? `.relations((r) => ({\n${relationObjectEntries.join("\n")}\n}))` : "";
+	const output = mode === "extension" ? `
+export function ${exportName ?? "authExtension"}() {
+  return defineSchemaExtension(${JSON.stringify(extensionKey ?? "auth")}, ${tableObject})${relationChain};
+}
+` : `
+export const tables = ${tableObject};
+
+const schema = defineSchema(tables)${relationChain};
+
+export default schema;
+`;
+	return {
+		code: `// This file is auto-generated. Do not edit this file manually.
+// To regenerate the schema, run:
+// \`${regenerateCommand ?? `npx @better-auth/cli generate --output ${file} -y`}\`
+
+${imports}
+
+${tableBlocks.join("\n\n")}
+${output}
+`,
+		overwrite: true,
+		path: file ?? "./schema.ts"
+	};
+};
+
+//#endregion
+export { createSchemaOrm };

package/dist/crpc/index.d.ts

@@ -0,0 +1,105 @@
+import { A as DataTransformer, F as decodeWire, I as defaultCRPCTransformer, L as encodeWire, M as WireCodec, N as createTaggedTransformer, O as CombinedDataTransformer, P as dateWireCodec, R as getTransformer, a as HttpProcedureCall, c as InferHttpInput, i as HttpErrorCode, j as DataTransformerOptions, k as DATE_CODEC_TAG, l as InferHttpOutput, n as HttpClientError, o as HttpRouteInfo, r as HttpClientFromRouter, s as HttpRouteMap, t as HttpClient, u as isHttpClientError, z as identityTransformer } from "../http-types-DqJubRPJ.js";
+import { A as HttpInputArgs, C as ReservedMutationOptions, D as VanillaMutation, E as VanillaAction, F as replaceUrlParam, M as RESERVED_KEYS, N as buildSearchParams, O as HttpClientOptions, P as executeHttpRequest, S as ReservedInfiniteQueryOptions, T as StaticQueryOptsParam, _ as IsPaginated, a as BaseInfiniteQueryOptsParam, b as PaginatedFnMeta, c as ConvexMutationKey, d as ConvexQueryMeta, f as EmptyObject, g as InfiniteQueryInput, h as FnMeta, i as BaseConvexQueryOptions, j as HttpProxyBaseOptions, k as HttpFormValue, l as ConvexQueryHookOptions, m as FUNC_REF_SYMBOL, n as BaseConvexActionOptions, o as ConvexActionKey, p as ExtractPaginatedItem, r as BaseConvexInfiniteQueryOptions, s as ConvexInfiniteQueryMeta, t as AuthType, u as ConvexQueryKey, v as Meta, w as ReservedQueryOptions, x as PaginationOpts, y as MutationVariables } from "../types-HhO_R6pd.js";
+import { FunctionArgs, FunctionReference } from "convex/server";
+
+//#region src/crpc/auth-error.d.ts
+/**
+ * Auth Mutation Error
+ *
+ * Framework-agnostic error class for Better Auth mutations.
+ */
+/**
+ * Error thrown when a Better Auth mutation fails.
+ * Contains the original error details from Better Auth.
+ */
+declare class AuthMutationError extends Error {
+  /** Error code from Better Auth (e.g., 'INVALID_PASSWORD', 'EMAIL_ALREADY_REGISTERED') */
+  code?: string;
+  /** HTTP status code */
+  status: number;
+  /** HTTP status text */
+  statusText: string;
+  constructor(authError: {
+    message?: string;
+    status: number;
+    statusText: string;
+    code?: string;
+  });
+}
+/**
+ * Type guard to check if an error is an AuthMutationError.
+ */
+declare function isAuthMutationError(error: unknown): error is AuthMutationError;
+//#endregion
+//#region src/crpc/error.d.ts
+/**
+ * Client error codes (subset of CRPC codes for client-side use)
+ */
+type ClientErrorCode = 'UNAUTHORIZED' | 'FORBIDDEN' | 'NOT_FOUND' | 'BAD_REQUEST' | 'TOO_MANY_REQUESTS';
+/**
+ * Client-side CRPC error.
+ * Mirrors backend CRPCError pattern with typed error codes.
+ */
+declare class CRPCClientError extends Error {
+  readonly name = "CRPCClientError";
+  readonly code: ClientErrorCode;
+  readonly functionName: string;
+  constructor(opts: {
+    code: ClientErrorCode;
+    functionName: string;
+    message?: string;
+  });
+}
+/** Type guard for CRPCClientError */
+declare const isCRPCClientError: (error: unknown) => error is CRPCClientError;
+/**
+ * Unified check for any deterministic CRPC error (Convex or HTTP).
+ * Use in retry logic to skip retrying client errors (4xx).
+ */
+declare const isCRPCError: (error: unknown) => boolean;
+/** Type guard for specific error code */
+declare const isCRPCErrorCode: (error: unknown, code: ClientErrorCode) => error is CRPCClientError;
+/** Default unauthorized detection - checks UNAUTHORIZED code */
+declare const defaultIsUnauthorized: (error: unknown) => boolean;
+//#endregion
+//#region src/crpc/query-options.d.ts
+/**
+ * Query options factory for Convex query function subscriptions.
+ * Requires `convexQueryClient.queryFn()` set as the default `queryFn` globally.
+ */
+declare function convexQuery<T extends FunctionReference<'query'>>(funcRef: T, args?: FunctionArgs<T> | 'skip', meta?: Meta, opts?: {
+  skipUnauth?: boolean;
+}): BaseConvexQueryOptions<T> & {
+  meta: ConvexQueryMeta;
+};
+/**
+ * Query options factory for Convex action functions.
+ * Actions are NOT reactive - they follow normal TanStack Query semantics.
+ *
+ * @example
+ * ```ts
+ * useQuery(convexAction(api.ai.generate, { prompt }))
+ * ```
+ *
+ * @example With additional options (use spread):
+ * ```ts
+ * useQuery({
+ *   ...convexAction(api.files.process, { fileId }),
+ *   staleTime: 60_000
+ * });
+ * ```
+ */
+declare function convexAction<T extends FunctionReference<'action'>>(funcRef: T, args?: FunctionArgs<T> | 'skip', meta?: Meta, opts?: {
+  skipUnauth?: boolean;
+}): BaseConvexActionOptions<T> & {
+  meta: ConvexQueryMeta;
+};
+/**
+ * Infinite query options factory for paginated Convex queries.
+ * Server-safe (non-hook) - can be used in RSC.
+ *
+ * Uses flat { cursor, limit } input like tRPC.
+ */
+declare function convexInfiniteQueryOptions<T extends FunctionReference<'query'>>(funcRef: T, args: Record<string, unknown> | 'skip', opts?: BaseInfiniteQueryOptsParam<T> & Record<string, unknown>, meta?: Meta): BaseConvexInfiniteQueryOptions<T> & Record<string, unknown>;
+//#endregion
+export { AuthMutationError, AuthType, BaseConvexActionOptions, BaseConvexInfiniteQueryOptions, BaseConvexQueryOptions, BaseInfiniteQueryOptsParam, CRPCClientError, CombinedDataTransformer, ConvexActionKey, ConvexInfiniteQueryMeta, ConvexMutationKey, ConvexQueryHookOptions, ConvexQueryKey, ConvexQueryMeta, DATE_CODEC_TAG, DataTransformer, DataTransformerOptions, EmptyObject, ExtractPaginatedItem, FUNC_REF_SYMBOL, FnMeta, HttpClient, HttpClientError, HttpClientFromRouter, HttpClientOptions, HttpErrorCode, HttpFormValue, HttpInputArgs, HttpProcedureCall, HttpProxyBaseOptions, HttpRouteInfo, HttpRouteMap, InferHttpInput, InferHttpOutput, InfiniteQueryInput, IsPaginated, Meta, MutationVariables, PaginatedFnMeta, PaginationOpts, RESERVED_KEYS, ReservedInfiniteQueryOptions, ReservedMutationOptions, ReservedQueryOptions, StaticQueryOptsParam, VanillaAction, VanillaMutation, WireCodec, buildSearchParams, convexAction, convexInfiniteQueryOptions, convexQuery, createTaggedTransformer, dateWireCodec, decodeWire, defaultCRPCTransformer, defaultIsUnauthorized, encodeWire, executeHttpRequest, getTransformer, identityTransformer, isAuthMutationError, isCRPCClientError, isCRPCError, isCRPCErrorCode, isHttpClientError, replaceUrlParam };