kitcn 0.0.1 → 0.12.0

package/bin/intent.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+await import('@tanstack/intent/intent-library');

package/dist/aggregate/index.d.ts

@@ -0,0 +1,388 @@
+import { C as ConvexNumberBuilderInitial, E as ConvexIdBuilderInitial, N as ConvexCustomBuilderInitial, dn as ConvexTableWithColumns, tr as ConvexTextBuilderInitial } from "../where-clause-compiler-DdjN63Io.js";
+import * as convex_values0 from "convex/values";
+import { GenericId, Infer, Value } from "convex/values";
+import { DocumentByName, GenericDataModel, GenericDatabaseReader, GenericDatabaseWriter, TableNamesInDataModel } from "convex/server";
+
+//#region src/aggregate-core/schema.d.ts
+declare const aggregateStorageTables: {
+  readonly aggregate_rank_node: ConvexTableWithColumns<{
+    name: "aggregate_rank_node";
+    columns: {
+      aggregate: ConvexCustomBuilderInitial<"", convex_values0.VObject<{
+        count: number;
+        sum: number;
+      }, {
+        count: convex_values0.VFloat64<number, "required">;
+        sum: convex_values0.VFloat64<number, "required">;
+      }, "required", "count" | "sum">> & {
+        _: {
+          tableName: "aggregate_rank_node";
+        };
+      } & {
+        _: {
+          fieldName: "aggregate";
+        };
+      };
+      items: ConvexCustomBuilderInitial<"", convex_values0.VArray<{
+        k: any;
+        v: any;
+        s: number;
+      }[], convex_values0.VObject<{
+        k: any;
+        v: any;
+        s: number;
+      }, {
+        k: convex_values0.VAny<any, "required", string>;
+        v: convex_values0.VAny<any, "required", string>;
+        s: convex_values0.VFloat64<number, "required">;
+      }, "required", "k" | "v" | "s" | `k.${string}` | `v.${string}`>, "required">> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_rank_node";
+        };
+      } & {
+        _: {
+          fieldName: "items";
+        };
+      };
+      subtrees: ConvexCustomBuilderInitial<"", convex_values0.VArray<string[], convex_values0.VString<string, "required">, "required">> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_rank_node";
+        };
+      } & {
+        _: {
+          fieldName: "subtrees";
+        };
+      };
+    };
+  }, {
+    by_creation_time: ["_creationTime"];
+  }, {}, {}, {}>;
+  readonly aggregate_rank_tree: ConvexTableWithColumns<{
+    name: "aggregate_rank_tree";
+    columns: {
+      aggregateName: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_rank_tree";
+        };
+      } & {
+        _: {
+          fieldName: "aggregateName";
+        };
+      };
+      maxNodeSize: ConvexNumberBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_rank_tree";
+        };
+      } & {
+        _: {
+          fieldName: "maxNodeSize";
+        };
+      };
+      namespace: ConvexCustomBuilderInitial<"", convex_values0.VAny<any, "required", string>> & {
+        _: {
+          tableName: "aggregate_rank_tree";
+        };
+      } & {
+        _: {
+          fieldName: "namespace";
+        };
+      };
+      root: ConvexIdBuilderInitial<"", "aggregate_rank_node"> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_rank_tree";
+        };
+      } & {
+        _: {
+          fieldName: "root";
+        };
+      };
+    };
+  }, {
+    by_creation_time: ["_creationTime"];
+    by_namespace: ["namespace", "_creationTime"];
+    by_aggregate_name: ["aggregateName", "_creationTime"];
+  }, {}, {}, {}>;
+};
+//#endregion
+//#region src/aggregate-core/btree.d.ts
+type Key$2 = Value;
+//#endregion
+//#region src/aggregate-core/positions.d.ts
+type Bound$1<K extends Key$2, ID extends string> = {
+  key: K;
+  id?: ID;
+  inclusive: boolean;
+};
+type SideBounds<K extends Key$2, ID extends string> = {
+  lower?: Bound$1<K, ID>;
+  upper?: Bound$1<K, ID>;
+};
+type TuplePrefix<K extends unknown[], P extends unknown[] = []> = P['length'] extends K['length'] ? P : P | TuplePrefix<K, [...P, K[P['length']]]>;
+type Bounds$1<K extends Key$2, ID extends string> = SideBounds<K, ID> | (K extends unknown[] ? {
+  prefix: TuplePrefix<Extract<K, unknown[]>>;
+} : never) | {
+  eq: K;
+};
+//#endregion
+//#region src/aggregate-core/runtime.d.ts
+type Key = Key$2;
+type Bound<K extends Key, ID extends string> = Bound$1<K, ID>;
+type Bounds<K extends Key, ID extends string> = Bounds$1<K, ID>;
+type AggregateQueryCtx = {
+  db: GenericDatabaseReader<any>;
+  orm: unknown;
+};
+type AggregateMutationCtx = {
+  db: GenericDatabaseWriter<any>;
+  orm: unknown;
+};
+type RunQueryCtx = AggregateQueryCtx;
+type RunMutationCtx = AggregateMutationCtx;
+type Item<K extends Key, ID extends string> = {
+  id: ID;
+  key: K;
+  sumValue: number;
+};
+/**
+ * Write data to be aggregated, and read aggregated data.
+ */
+declare class Aggregate<K extends Key, ID extends string, TNamespace extends Value | undefined = undefined> {
+  protected readonly aggregateName: string;
+  constructor(aggregateName: string);
+  count(ctx: RunQueryCtx, ...opts: NamespacedOpts<{
+    bounds?: Bounds<K, ID>;
+  }, TNamespace>): Promise<number>;
+  countBatch(ctx: RunQueryCtx, queries: NamespacedOptsBatch<{
+    bounds?: Bounds<K, ID>;
+  }, TNamespace>): Promise<number[]>;
+  sum(ctx: RunQueryCtx, ...opts: NamespacedOpts<{
+    bounds?: Bounds<K, ID>;
+  }, TNamespace>): Promise<number>;
+  sumBatch(ctx: RunQueryCtx, queries: NamespacedOptsBatch<{
+    bounds?: Bounds<K, ID>;
+  }, TNamespace>): Promise<number[]>;
+  at(ctx: RunQueryCtx, offset: number, ...opts: NamespacedOpts<{
+    bounds?: Bounds<K, ID>;
+  }, TNamespace>): Promise<Item<K, ID>>;
+  atBatch(ctx: RunQueryCtx, queries: NamespacedOptsBatch<{
+    offset: number;
+    bounds?: Bounds<K, ID>;
+  }, TNamespace>): Promise<Item<K, ID>[]>;
+  indexOf(ctx: RunQueryCtx, key: K, ...opts: NamespacedOpts<{
+    bounds?: Bounds<K, ID>;
+    id?: ID;
+    order?: 'asc' | 'desc';
+  }, TNamespace>): Promise<number>;
+  offsetOf(ctx: RunQueryCtx, key: K, namespace: TNamespace, id?: ID, bounds?: Bounds<K, ID>): Promise<number>;
+  offsetUntil(ctx: RunQueryCtx, key: K, namespace: TNamespace, id?: ID, bounds?: Bounds<K, ID>): Promise<number>;
+  min(ctx: RunQueryCtx, ...opts: NamespacedOpts<{
+    bounds?: Bounds<K, ID>;
+  }, TNamespace>): Promise<Item<K, ID> | null>;
+  max(ctx: RunQueryCtx, ...opts: NamespacedOpts<{
+    bounds?: Bounds<K, ID>;
+  }, TNamespace>): Promise<Item<K, ID> | null>;
+  random(ctx: RunQueryCtx, ...opts: NamespacedOpts<{
+    bounds?: Bounds<K, ID>;
+  }, TNamespace>): Promise<Item<K, ID> | null>;
+  paginate(ctx: RunQueryCtx, ...opts: NamespacedOpts<{
+    bounds?: Bounds<K, ID>;
+    cursor?: string;
+    order?: 'asc' | 'desc';
+    pageSize?: number;
+  }, TNamespace>): Promise<{
+    cursor: string;
+    isDone: boolean;
+    page: Item<K, ID>[];
+  }>;
+  iter(ctx: RunQueryCtx, ...opts: NamespacedOpts<{
+    bounds?: Bounds<K, ID>;
+    order?: 'asc' | 'desc';
+    pageSize?: number;
+  }, TNamespace>): AsyncGenerator<Item<K, ID>, void, undefined>;
+  _insert(ctx: RunMutationCtx, namespace: TNamespace, key: K, id: ID, summand?: number): Promise<void>;
+  _delete(ctx: RunMutationCtx, namespace: TNamespace, key: K, id: ID): Promise<void>;
+  _replace(ctx: RunMutationCtx, currentNamespace: TNamespace, currentKey: K, newNamespace: TNamespace, newKey: K, id: ID, summand?: number): Promise<void>;
+  _insertIfDoesNotExist(ctx: RunMutationCtx, namespace: TNamespace, key: K, id: ID, summand?: number): Promise<void>;
+  _deleteIfExists(ctx: RunMutationCtx, namespace: TNamespace, key: K, id: ID): Promise<void>;
+  _replaceOrInsert(ctx: RunMutationCtx, currentNamespace: TNamespace, currentKey: K, newNamespace: TNamespace, newKey: K, id: ID, summand?: number): Promise<void>;
+  clear(ctx: RunMutationCtx, ...opts: NamespacedOpts<{
+    maxNodeSize?: number;
+    rootLazy?: boolean;
+  }, TNamespace>): Promise<void>;
+  makeRootLazy(ctx: RunMutationCtx, namespace: TNamespace): Promise<void>;
+  paginateNamespaces(ctx: RunQueryCtx, cursor?: string, pageSize?: number): Promise<{
+    cursor: string;
+    isDone: boolean;
+    page: TNamespace[];
+  }>;
+  iterNamespaces(ctx: RunQueryCtx, pageSize?: number): AsyncGenerator<TNamespace, void, undefined>;
+  clearAll(ctx: RunMutationCtx & RunQueryCtx, opts?: {
+    maxNodeSize?: number;
+    rootLazy?: boolean;
+  }): Promise<void>;
+  makeAllRootsLazy(ctx: RunMutationCtx & RunQueryCtx): Promise<void>;
+}
+type DirectAggregateType<K extends Key, ID extends string, TNamespace extends Value | undefined = undefined> = {
+  Key: K;
+  Id: ID;
+  Namespace?: TNamespace;
+};
+type AnyDirectAggregateType$1 = DirectAggregateType<Key, string, Value | undefined>;
+type DirectAggregateNamespace<T extends AnyDirectAggregateType$1> = 'Namespace' extends keyof T ? T['Namespace'] : undefined;
+declare class DirectAggregate$1<T extends AnyDirectAggregateType$1> extends Aggregate<T['Key'], T['Id'], DirectAggregateNamespace<T>> {
+  constructor(config: {
+    name: string;
+  });
+  insert(ctx: RunMutationCtx, args: NamespacedArgs<{
+    id: T['Id'];
+    key: T['Key'];
+    sumValue?: number;
+  }, DirectAggregateNamespace<T>>): Promise<void>;
+  delete(ctx: RunMutationCtx, args: NamespacedArgs<{
+    id: T['Id'];
+    key: T['Key'];
+  }, DirectAggregateNamespace<T>>): Promise<void>;
+  replace(ctx: RunMutationCtx, currentItem: NamespacedArgs<{
+    id: T['Id'];
+    key: T['Key'];
+  }, DirectAggregateNamespace<T>>, newItem: NamespacedArgs<{
+    key: T['Key'];
+    sumValue?: number;
+  }, DirectAggregateNamespace<T>>): Promise<void>;
+  insertIfDoesNotExist(ctx: RunMutationCtx, args: NamespacedArgs<{
+    id: T['Id'];
+    key: T['Key'];
+    sumValue?: number;
+  }, DirectAggregateNamespace<T>>): Promise<void>;
+  deleteIfExists(ctx: RunMutationCtx, args: NamespacedArgs<{
+    id: T['Id'];
+    key: T['Key'];
+  }, DirectAggregateNamespace<T>>): Promise<void>;
+  replaceOrInsert(ctx: RunMutationCtx, currentItem: NamespacedArgs<{
+    id: T['Id'];
+    key: T['Key'];
+  }, DirectAggregateNamespace<T>>, newItem: NamespacedArgs<{
+    key: T['Key'];
+    sumValue?: number;
+  }, DirectAggregateNamespace<T>>): Promise<void>;
+}
+type TableAggregateType<K extends Key, DataModel extends GenericDataModel, TableName extends TableNamesInDataModel<DataModel>, TNamespace extends Value | undefined = undefined> = {
+  DataModel: DataModel;
+  Key: K;
+  Namespace?: TNamespace;
+  TableName: TableName;
+};
+type AnyTableAggregateType$1 = TableAggregateType<Key, GenericDataModel, TableNamesInDataModel<GenericDataModel>, Value | undefined>;
+type TableAggregateNamespace<T extends AnyTableAggregateType$1> = 'Namespace' extends keyof T ? T['Namespace'] : undefined;
+type TableAggregateDocument<T extends AnyTableAggregateType$1> = DocumentByName<T['DataModel'], T['TableName']>;
+type TableAggregateId<T extends AnyTableAggregateType$1> = GenericId<T['TableName']>;
+type TableAggregateTrigger<Ctx, T extends AnyTableAggregateType$1> = Trigger<Ctx, T['DataModel'], T['TableName']>;
+declare class TableAggregate$1<T extends AnyTableAggregateType$1> extends Aggregate<T['Key'], GenericId<T['TableName']>, TableAggregateNamespace<T>> {
+  constructor(options: {
+    name: string;
+    table: T['TableName'];
+    sortKey: (d: TableAggregateDocument<T>) => T['Key'];
+    sumValue?: (d: TableAggregateDocument<T>) => number;
+  } & (undefined extends TableAggregateNamespace<T> ? {
+    namespace?: (d: TableAggregateDocument<T>) => TableAggregateNamespace<T>;
+  } : {
+    namespace: (d: TableAggregateDocument<T>) => TableAggregateNamespace<T>;
+  }));
+  private readonly options;
+  insert(ctx: RunMutationCtx, doc: TableAggregateDocument<T>): Promise<void>;
+  delete(ctx: RunMutationCtx, doc: TableAggregateDocument<T>): Promise<void>;
+  replace(ctx: RunMutationCtx, oldDoc: TableAggregateDocument<T>, newDoc: TableAggregateDocument<T>): Promise<void>;
+  insertIfDoesNotExist(ctx: RunMutationCtx, doc: TableAggregateDocument<T>): Promise<void>;
+  deleteIfExists(ctx: RunMutationCtx, doc: TableAggregateDocument<T>): Promise<void>;
+  replaceOrInsert(ctx: RunMutationCtx, oldDoc: TableAggregateDocument<T>, newDoc: TableAggregateDocument<T>): Promise<void>;
+  indexOfDoc(ctx: RunQueryCtx, doc: TableAggregateDocument<T>, opts?: {
+    id?: TableAggregateId<T>;
+    bounds?: Bounds<T['Key'], TableAggregateId<T>>;
+    order?: 'asc' | 'desc';
+  }): Promise<number>;
+  trigger<Ctx extends RunMutationCtx>(): TableAggregateTrigger<Ctx, T>;
+  idempotentTrigger<Ctx extends RunMutationCtx>(): TableAggregateTrigger<Ctx, T>;
+}
+type Trigger<Ctx, DataModel extends GenericDataModel, TableName extends TableNamesInDataModel<DataModel>> = (ctx: Ctx, change: Change<DataModel, TableName>) => Promise<void>;
+type Change<DataModel extends GenericDataModel, TableName extends TableNamesInDataModel<DataModel>> = {
+  id: GenericId<TableName> | string;
+} & ({
+  operation: 'insert';
+  oldDoc: null;
+  newDoc: DocumentByName<DataModel, TableName>;
+} | {
+  operation: 'update';
+  oldDoc: DocumentByName<DataModel, TableName>;
+  newDoc: DocumentByName<DataModel, TableName>;
+} | {
+  operation: 'delete';
+  oldDoc: DocumentByName<DataModel, TableName>;
+  newDoc: null;
+});
+type NamespacedArgs<Args, TNamespace> = (Args & {
+  namespace: TNamespace;
+}) | (TNamespace extends undefined ? Args : never);
+type NamespacedOpts<Opts, TNamespace> = [{
+  namespace: TNamespace;
+} & Opts] | (undefined extends TNamespace ? [Opts?] : never);
+type NamespacedOptsBatch<Opts, TNamespace> = Array<undefined extends TNamespace ? Opts : {
+  namespace: TNamespace;
+} & Opts>;
+//#endregion
+//#region src/orm/aggregate.d.ts
+type AggregateTriggerFactoryLike = {
+  trigger: () => (ctx: unknown, change: unknown) => Promise<void>;
+};
+type AggregateTriggerCtx<T extends AggregateTriggerFactoryLike> = Parameters<ReturnType<T['trigger']>>[0];
+type AggregateTriggerChange<T extends AggregateTriggerFactoryLike> = Parameters<ReturnType<T['trigger']>>[1];
+type AggregateTriggerOverload<T extends AggregateTriggerFactoryLike> = {
+  (): ReturnType<T['trigger']>;
+  <TChange, TCtx>(change: TChange, ctx: TCtx): Promise<void>;
+};
+type OrmCompatibleAggregate<T extends AggregateTriggerFactoryLike> = Omit<T, 'trigger'> & {
+  trigger: AggregateTriggerOverload<T>;
+};
+//#endregion
+//#region src/aggregate/index.d.ts
+type Key$1 = Key;
+type AnyDirectAggregateType = DirectAggregateType<Key$1, string, Value | undefined>;
+type AnyTableAggregateType = TableAggregateType<Key$1, any, any, Value | undefined>;
+type CoreTrigger<T extends AnyTableAggregateType> = ReturnType<TableAggregate$1<T>['trigger']>;
+type CoreIdempotentTrigger<T extends AnyTableAggregateType> = ReturnType<TableAggregate$1<T>['idempotentTrigger']>;
+declare class TableAggregate<T extends AnyTableAggregateType> extends TableAggregate$1<T> {
+  trigger: {
+    (): CoreTrigger<T>;
+    <TChange, TCtx>(change: TChange, ctx: TCtx): Promise<void>;
+  };
+  idempotentTrigger: {
+    (): CoreIdempotentTrigger<T>;
+    <TChange, TCtx>(change: TChange, ctx: TCtx): Promise<void>;
+  };
+  constructor(...args: ConstructorParameters<typeof TableAggregate$1>);
+}
+declare class DirectAggregate<T extends AnyDirectAggregateType> extends DirectAggregate$1<T> {}
+declare function createDirectAggregate<T extends AnyDirectAggregateType>(config: {
+  name: string;
+}): DirectAggregate<T>;
+//#endregion
+export { type AggregateTriggerChange, type AggregateTriggerCtx, type AggregateTriggerFactoryLike, type Bound, type Bounds, DirectAggregate, type DirectAggregateType, type Item, type Key, type OrmCompatibleAggregate, type RunMutationCtx, type RunQueryCtx, TableAggregate, type TableAggregateType, aggregateStorageTables, createDirectAggregate };

package/dist/aggregate/index.js

@@ -0,0 +1,37 @@
+import { n as TableAggregate$1, r as aggregateStorageTables, t as DirectAggregate$1 } from "../runtime-CtvJPkur.js";
+
+//#region src/aggregate/index.ts
+const wrapTriggerFactory = (methodName, factory) => ((...args) => {
+	if (args.length === 0) return factory();
+	if (args.length === 2) {
+		const [change, ctx] = args;
+		return factory()(ctx, change);
+	}
+	throw new Error(`Invalid aggregate.${methodName} invocation. Use ${methodName}() or ${methodName}(change, ctx).`);
+});
+var TableAggregate = class extends TableAggregate$1 {
+	constructor(...args) {
+		super(...args);
+		const triggerFactory = super.trigger.bind(this);
+		const idempotentFactory = super.idempotentTrigger.bind(this);
+		Object.defineProperty(this, "trigger", {
+			configurable: true,
+			enumerable: false,
+			value: wrapTriggerFactory("trigger", triggerFactory),
+			writable: true
+		});
+		Object.defineProperty(this, "idempotentTrigger", {
+			configurable: true,
+			enumerable: false,
+			value: wrapTriggerFactory("idempotentTrigger", idempotentFactory),
+			writable: true
+		});
+	}
+};
+var DirectAggregate = class extends DirectAggregate$1 {};
+function createDirectAggregate(config) {
+	return new DirectAggregate(config);
+}
+
+//#endregion
+export { DirectAggregate, TableAggregate, aggregateStorageTables, createDirectAggregate };

package/dist/api-entry-BckXqaLb.js

@@ -0,0 +1,66 @@
+import { getFunctionName, makeFunctionReference } from "convex/server";
+
+//#region src/server/context-utils.ts
+const isQueryCtx = (ctx) => "db" in ctx;
+const isMutationCtx = (ctx) => "db" in ctx && "scheduler" in ctx;
+const isActionCtx = (ctx) => "runAction" in ctx;
+const isRunMutationCtx = (ctx) => "runMutation" in ctx;
+const requireQueryCtx = (ctx) => {
+	if (!isQueryCtx(ctx)) throw new Error("Query context required");
+	return ctx;
+};
+const requireMutationCtx = (ctx) => {
+	if (!isMutationCtx(ctx)) throw new Error("Mutation context required");
+	return ctx;
+};
+const requireActionCtx = (ctx) => {
+	if (!isActionCtx(ctx)) throw new Error("Action context required");
+	return ctx;
+};
+const requireRunMutationCtx = (ctx) => {
+	if (!isRunMutationCtx(ctx)) throw new Error("Mutation or action context required");
+	return ctx;
+};
+
+//#endregion
+//#region src/server/api-entry.ts
+function getGeneratedValue(root, path) {
+	let current = root;
+	for (let index = 0; index < path.length; index += 1) {
+		const segment = path[index];
+		if (typeof current !== "object" || current === null) throw new Error(`[kitcn] Invalid generated path: ${path.join(".")}`);
+		const directValue = current[segment];
+		if (directValue !== void 0) {
+			current = directValue;
+			continue;
+		}
+		let matched = false;
+		for (let end = path.length - 1; end > index; end -= 1) {
+			const collapsedSegment = path.slice(index, end + 1).join("/");
+			const collapsedValue = current[collapsedSegment];
+			if (collapsedValue === void 0) continue;
+			current = collapsedValue;
+			index = end;
+			matched = true;
+			break;
+		}
+		if (!matched) throw new Error(`[kitcn] Invalid generated path: ${path.join(".")}`);
+	}
+	return current;
+}
+/**
+* Build a generated API leaf from a Convex FunctionReference name.
+* Returns a plain FunctionReference-compatible object with attached cRPC metadata.
+*/
+function createApiLeaf(...args) {
+	const [fnOrRoot, pathOrMeta, maybeMeta] = args;
+	const meta = maybeMeta ?? pathOrMeta;
+	const functionRef = makeFunctionReference(getFunctionName(Array.isArray(pathOrMeta) ? getGeneratedValue(fnOrRoot, pathOrMeta) : fnOrRoot));
+	return Object.assign(functionRef, meta, { functionRef });
+}
+function createGeneratedFunctionReference(name) {
+	return makeFunctionReference(name);
+}
+
+//#endregion
+export { isMutationCtx as a, requireActionCtx as c, requireRunMutationCtx as d, isActionCtx as i, requireMutationCtx as l, createGeneratedFunctionReference as n, isQueryCtx as o, getGeneratedValue as r, isRunMutationCtx as s, createApiLeaf as t, requireQueryCtx as u };

package/dist/auth/client/index.d.ts

@@ -0,0 +1,37 @@
+'use client';
+import { convexClient } from "@convex-dev/better-auth/client/plugins";
+import { ConvexReactClient } from "convex/react";
+import { ReactNode } from "react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { AuthClient, AuthClient as AuthClient$1 } from "@convex-dev/better-auth/react";
+
+//#region src/auth-client/convex-auth-provider.d.ts
+type ConvexAuthProviderProps = {
+  children: ReactNode; /** Convex client instance */
+  client: ConvexReactClient; /** Better Auth client instance */
+  authClient: AuthClient$1; /** Initial session token (from SSR) */
+  initialToken?: string; /** Callback when mutation called while unauthorized */
+  onMutationUnauthorized?: () => void; /** Callback when query called while unauthorized */
+  onQueryUnauthorized?: (info: {
+    queryName: string;
+  }) => void; /** Custom function to detect UNAUTHORIZED errors. Default checks code property. */
+  isUnauthorized?: (error: unknown) => boolean;
+};
+/**
+ * Unified auth provider for Convex + Better Auth.
+ * Handles token sync, HMR persistence, and auth callbacks.
+ *
+ * Structure: AuthProvider wraps ConvexAuthProviderInner so that
+ * useAuthStore() is available when creating fetchAccessToken.
+ */
+declare function ConvexAuthProvider({
+  children,
+  client,
+  authClient,
+  initialToken,
+  onMutationUnauthorized,
+  onQueryUnauthorized,
+  isUnauthorized
+}: ConvexAuthProviderProps): react_jsx_runtime0.JSX.Element;
+//#endregion
+export { type AuthClient, ConvexAuthProvider, ConvexAuthProviderProps, convexClient };