kitcn 0.0.1 → 0.12.1

package/dist/generated-contract-disabled-D-sOFy92.d.ts

@@ -0,0 +1,354 @@
+import { t as GetAuth } from "./types-BiJE7qxR.js";
+import { t as GenericCtx } from "./context-utils-HPC5nXzx.js";
+import * as convex_server0 from "convex/server";
+import { DocumentByName, FunctionReference, GenericDataModel, GenericMutationCtx, GenericSchema, SchemaDefinition, TableNamesInDataModel, internalMutationGeneric } from "convex/server";
+import * as better_auth_adapters0 from "better-auth/adapters";
+import { BetterAuthOptions } from "better-auth/minimal";
+import { Auth } from "better-auth";
+
+//#region src/auth/define-auth.d.ts
+type MaybePromise$1<T> = T | Promise<T>;
+type TableDoc<DataModel extends GenericDataModel, TableName extends string> = TableName extends TableNamesInDataModel<DataModel> ? DocumentByName<DataModel, TableName> extends Record<string, unknown> ? DocumentByName<DataModel, TableName> : Record<string, unknown> : Record<string, unknown>;
+type InsertDocData<TDoc extends Record<string, unknown>> = Omit<TDoc, '_id' | '_creationTime'>;
+type UpdateDocData<TDoc extends Record<string, unknown>> = Partial<Omit<TDoc, '_id' | '_creationTime'>>;
+type TriggerChangeId<TDoc> = TDoc extends {
+  _id: infer TId;
+} ? TId : TDoc extends {
+  id: infer TId;
+} ? TId : unknown;
+type GenericAuthTriggerChange<TDoc extends Record<string, unknown> = Record<string, unknown>, TId = TriggerChangeId<TDoc>> = {
+  id: TId;
+  newDoc: TDoc;
+  oldDoc: null;
+  operation: 'insert';
+} | {
+  id: TId;
+  newDoc: TDoc;
+  oldDoc: TDoc;
+  operation: 'update';
+} | {
+  id: TId;
+  newDoc: null;
+  oldDoc: TDoc;
+  operation: 'delete';
+};
+type GenericAuthBeforeResult<TData extends Record<string, unknown>> = void | false | {
+  data: Partial<TData>;
+};
+type GenericAuthTriggerHandlers<DataModel extends GenericDataModel, TableName extends string, TriggerCtx, Doc extends Record<string, unknown> = TableDoc<DataModel, TableName>, InsertDoc extends Record<string, unknown> = InsertDocData<Doc>, UpdateDoc extends Record<string, unknown> = UpdateDocData<Doc>> = {
+  change?: (change: GenericAuthTriggerChange<Doc>, ctx: TriggerCtx) => MaybePromise$1<void>;
+  create?: {
+    after?: (doc: Doc, ctx: TriggerCtx) => MaybePromise$1<void>;
+    before?: (data: InsertDoc, ctx: TriggerCtx) => MaybePromise$1<GenericAuthBeforeResult<InsertDoc>>;
+  };
+  delete?: {
+    after?: (doc: Doc, ctx: TriggerCtx) => MaybePromise$1<void>;
+    before?: (doc: Doc, ctx: TriggerCtx) => MaybePromise$1<GenericAuthBeforeResult<Doc>>;
+  };
+  update?: {
+    after?: (newDoc: Doc, ctx: TriggerCtx) => MaybePromise$1<void>;
+    before?: (update: UpdateDoc, ctx: TriggerCtx) => MaybePromise$1<GenericAuthBeforeResult<UpdateDoc>>;
+  };
+};
+type GenericAuthTriggers<DataModel extends GenericDataModel, Schema extends SchemaDefinition<any, any>, TriggerCtx = unknown> = { [K in keyof Schema['tables'] & string]?: GenericAuthTriggerHandlers<DataModel, K, TriggerCtx> };
+type BetterAuthOptionsWithoutDatabase = Omit<BetterAuthOptions, 'database'>;
+type GenericAuthDefinition<GenericCtx = unknown, DataModel extends GenericDataModel = GenericDataModel, Schema extends SchemaDefinition<GenericSchema, true> = SchemaDefinition<GenericSchema, true>, AuthOptions extends BetterAuthOptionsWithoutDatabase = BetterAuthOptionsWithoutDatabase> = (ctx: GenericCtx) => AuthOptions & {
+  triggers?: GenericAuthTriggers<DataModel, Schema, GenericCtx>;
+};
+declare const defineAuth: <GenericCtx = unknown, DataModel extends GenericDataModel = GenericDataModel, Schema extends SchemaDefinition<GenericSchema, true> = SchemaDefinition<GenericSchema, true>, AuthOptions extends BetterAuthOptionsWithoutDatabase = BetterAuthOptionsWithoutDatabase>(definition: GenericAuthDefinition<GenericCtx, DataModel, Schema, AuthOptions>) => GenericAuthDefinition<GenericCtx, DataModel, Schema, AuthOptions>;
+//#endregion
+//#region src/auth/create-api.d.ts
+type Schema = SchemaDefinition<any, any>;
+type MaybePromise<T> = T | Promise<T>;
+type RuntimeBeforeResult = GenericAuthBeforeResult<Record<string, unknown>>;
+type RuntimeTriggerChange = GenericAuthTriggerChange<Record<string, unknown>>;
+type RuntimeTableTriggers = {
+  change?: (change: RuntimeTriggerChange, ctx: unknown) => MaybePromise<void>;
+  create?: {
+    after?: (doc: Record<string, unknown>, ctx: unknown) => MaybePromise<void>;
+    before?: (data: Record<string, unknown>, ctx: unknown) => MaybePromise<RuntimeBeforeResult>;
+  };
+  delete?: {
+    after?: (doc: Record<string, unknown>, ctx: unknown) => MaybePromise<void>;
+    before?: (doc: Record<string, unknown>, ctx: unknown) => MaybePromise<RuntimeBeforeResult>;
+  };
+  update?: {
+    after?: (doc: Record<string, unknown>, ctx: unknown) => MaybePromise<void>;
+    before?: (update: Record<string, unknown>, ctx: unknown) => MaybePromise<RuntimeBeforeResult>;
+  };
+};
+declare const createHandler: (ctx: any, args: {
+  input: {
+    data: any;
+    model: string;
+  };
+  select?: string[];
+  tableTriggers?: RuntimeTableTriggers;
+  triggerCtx?: unknown;
+}, schema: Schema, betterAuthSchema: any) => Promise<any>;
+declare const findOneHandler: (ctx: any, args: {
+  model: string;
+  select?: string[];
+  where?: any[];
+}, schema: Schema, betterAuthSchema: any) => Promise<convex_server0.GenericDocument | null>;
+declare const findManyHandler: (ctx: any, args: {
+  model: string;
+  paginationOpts: any;
+  limit?: number;
+  offset?: number;
+  sortBy?: {
+    direction: "asc" | "desc";
+    field: string;
+  };
+  where?: any[];
+}, schema: Schema, betterAuthSchema: any) => Promise<convex_server0.PaginationResult<convex_server0.GenericDocument>>;
+declare const updateOneHandler: (ctx: any, args: {
+  input: {
+    model: string;
+    update: any;
+    where?: any[];
+  };
+  tableTriggers?: RuntimeTableTriggers;
+  triggerCtx?: unknown;
+}, schema: Schema, betterAuthSchema: any) => Promise<any>;
+declare const updateManyHandler: (ctx: any, args: {
+  input: {
+    model: string;
+    update?: any;
+    where?: any[];
+  };
+  paginationOpts: any;
+  tableTriggers?: RuntimeTableTriggers;
+  triggerCtx?: unknown;
+}, schema: Schema, betterAuthSchema: any) => Promise<{
+  count: number;
+  ids: any[];
+  isDone: boolean;
+  continueCursor: convex_server0.Cursor;
+  splitCursor?: convex_server0.Cursor | null;
+  pageStatus?: "SplitRecommended" | "SplitRequired" | null;
+}>;
+declare const deleteOneHandler: (ctx: any, args: {
+  input: {
+    model: string;
+    where?: any[];
+  };
+  tableTriggers?: RuntimeTableTriggers;
+  triggerCtx?: unknown;
+}, schema: Schema, betterAuthSchema: any) => Promise<Record<string, unknown> | undefined>;
+declare const deleteManyHandler: (ctx: any, args: {
+  input: {
+    model: string;
+    where?: any[];
+  };
+  paginationOpts: any;
+  tableTriggers?: RuntimeTableTriggers;
+  triggerCtx?: unknown;
+}, schema: Schema, betterAuthSchema: any) => Promise<{
+  count: number;
+  ids: any[];
+  isDone: boolean;
+  continueCursor: convex_server0.Cursor;
+  splitCursor?: convex_server0.Cursor | null;
+  pageStatus?: "SplitRecommended" | "SplitRequired" | null;
+}>;
+declare const createApi: <Schema extends SchemaDefinition<any, any>, DataModel extends GenericDataModel = GenericDataModel, Ctx = unknown, TriggerCtx = Ctx, Auth = unknown>(schema: Schema, getAuth: GetAuth<Ctx, Auth>, options?: {
+  internalMutation?: typeof internalMutationGeneric;
+  context?: (ctx: any) => TriggerCtx | Promise<TriggerCtx>;
+  triggers?: GenericAuthTriggers<DataModel, Schema, TriggerCtx> | ((ctx: TriggerCtx) => GenericAuthTriggers<DataModel, Schema, TriggerCtx> | undefined); /** Validate input validators against auth table schemas. Defaults to false for smaller generated types. */
+  validateInput?: boolean;
+}) => {
+  create: convex_server0.RegisteredMutation<"internal", {
+    select?: string[] | undefined;
+    input: {
+      data: {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+      };
+      model: string;
+    } | {
+      data: any;
+      model: string;
+    };
+  }, Promise<any>>;
+  deleteMany: convex_server0.RegisteredMutation<"internal", {
+    input: {
+      where?: {
+        connector?: "AND" | "OR" | undefined;
+        operator?: "lt" | "lte" | "gt" | "gte" | "eq" | "in" | "not_in" | "ne" | "contains" | "starts_with" | "ends_with" | undefined;
+        value: string | number | boolean | string[] | number[] | null;
+        field: string;
+      }[] | undefined;
+      model: string;
+    } | {
+      where?: any[] | undefined;
+      model: string;
+    };
+    paginationOpts: {
+      id?: number;
+      endCursor?: string | null;
+      maximumRowsRead?: number;
+      maximumBytesRead?: number;
+      numItems: number;
+      cursor: string | null;
+    };
+  }, Promise<{
+    count: number;
+    ids: any[];
+    isDone: boolean;
+    continueCursor: convex_server0.Cursor;
+    splitCursor?: convex_server0.Cursor | null;
+    pageStatus?: "SplitRecommended" | "SplitRequired" | null;
+  }>>;
+  deleteOne: convex_server0.RegisteredMutation<"internal", {
+    input: {
+      where?: {
+        connector?: "AND" | "OR" | undefined;
+        operator?: "lt" | "lte" | "gt" | "gte" | "eq" | "in" | "not_in" | "ne" | "contains" | "starts_with" | "ends_with" | undefined;
+        value: string | number | boolean | string[] | number[] | null;
+        field: string;
+      }[] | undefined;
+      model: string;
+    } | {
+      where?: any[] | undefined;
+      model: string;
+    };
+  }, Promise<Record<string, unknown> | undefined>>;
+  findMany: convex_server0.RegisteredQuery<"internal", {
+    join?: any;
+    where?: {
+      connector?: "AND" | "OR" | undefined;
+      operator?: "lt" | "lte" | "gt" | "gte" | "eq" | "in" | "not_in" | "ne" | "contains" | "starts_with" | "ends_with" | undefined;
+      value: string | number | boolean | string[] | number[] | null;
+      field: string;
+    }[] | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+    sortBy?: {
+      field: string;
+      direction: "asc" | "desc";
+    } | undefined;
+    model: string;
+    paginationOpts: {
+      id?: number;
+      endCursor?: string | null;
+      maximumRowsRead?: number;
+      maximumBytesRead?: number;
+      numItems: number;
+      cursor: string | null;
+    };
+  }, Promise<convex_server0.PaginationResult<convex_server0.GenericDocument>>>;
+  findOne: convex_server0.RegisteredQuery<"internal", {
+    join?: any;
+    select?: string[] | undefined;
+    where?: {
+      connector?: "AND" | "OR" | undefined;
+      operator?: "lt" | "lte" | "gt" | "gte" | "eq" | "in" | "not_in" | "ne" | "contains" | "starts_with" | "ends_with" | undefined;
+      value: string | number | boolean | string[] | number[] | null;
+      field: string;
+    }[] | undefined;
+    model: string;
+  }, Promise<convex_server0.GenericDocument | null>>;
+  getLatestJwks: convex_server0.RegisteredAction<"internal", {}, Promise<unknown>>;
+  rotateKeys: convex_server0.RegisteredAction<"internal", {}, Promise<unknown>>;
+  updateMany: convex_server0.RegisteredMutation<"internal", {
+    input: {
+      where?: {
+        connector?: "AND" | "OR" | undefined;
+        operator?: "lt" | "lte" | "gt" | "gte" | "eq" | "in" | "not_in" | "ne" | "contains" | "starts_with" | "ends_with" | undefined;
+        value: string | number | boolean | string[] | number[] | null;
+        field: string;
+      }[] | undefined;
+      model: string;
+      update: {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+      };
+    } | {
+      where?: any[] | undefined;
+      model: string;
+      update: any;
+    };
+    paginationOpts: {
+      id?: number;
+      endCursor?: string | null;
+      maximumRowsRead?: number;
+      maximumBytesRead?: number;
+      numItems: number;
+      cursor: string | null;
+    };
+  }, Promise<{
+    count: number;
+    ids: any[];
+    isDone: boolean;
+    continueCursor: convex_server0.Cursor;
+    splitCursor?: convex_server0.Cursor | null;
+    pageStatus?: "SplitRecommended" | "SplitRequired" | null;
+  }>>;
+  updateOne: convex_server0.RegisteredMutation<"internal", {
+    input: {
+      where?: {
+        connector?: "AND" | "OR" | undefined;
+        operator?: "lt" | "lte" | "gt" | "gte" | "eq" | "in" | "not_in" | "ne" | "contains" | "starts_with" | "ends_with" | undefined;
+        value: string | number | boolean | string[] | number[] | null;
+        field: string;
+      }[] | undefined;
+      model: string;
+      update: {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+      };
+    } | {
+      where?: any[] | undefined;
+      model: string;
+      update: any;
+    };
+  }, Promise<any>>;
+};
+//#endregion
+//#region src/auth/create-client.d.ts
+type AuthFunctions = {
+  create: FunctionReference<'mutation', 'internal', Record<string, any>>;
+  deleteMany: FunctionReference<'mutation', 'internal', Record<string, any>>;
+  deleteOne: FunctionReference<'mutation', 'internal', Record<string, any>>;
+  findMany: FunctionReference<'query', 'internal', Record<string, any>>;
+  findOne: FunctionReference<'query', 'internal', Record<string, any>>;
+  updateMany: FunctionReference<'mutation', 'internal', Record<string, any>>;
+  updateOne: FunctionReference<'mutation', 'internal', Record<string, any>>;
+};
+type Triggers<DataModel extends GenericDataModel, Schema extends SchemaDefinition<any, any>, TriggerCtx = unknown> = GenericAuthTriggers<DataModel, Schema, TriggerCtx>;
+type TriggerResolver<DataModel extends GenericDataModel, Schema extends SchemaDefinition<any, any>, TriggerCtx extends GenericMutationCtx<DataModel> = GenericMutationCtx<DataModel>> = Triggers<DataModel, Schema, TriggerCtx> | ((ctx: TriggerCtx) => Triggers<DataModel, Schema, TriggerCtx> | undefined);
+declare const createClient: <DataModel extends GenericDataModel, Schema extends SchemaDefinition<GenericSchema, true>, TriggerCtx extends GenericMutationCtx<DataModel> = GenericMutationCtx<DataModel>>(config: {
+  authFunctions: AuthFunctions;
+  schema: Schema;
+  context?: (ctx: GenericMutationCtx<DataModel>) => TriggerCtx | Promise<TriggerCtx>;
+  triggers?: TriggerResolver<DataModel, Schema, TriggerCtx>;
+}) => {
+  authFunctions: AuthFunctions;
+  triggers: TriggerResolver<DataModel, Schema, TriggerCtx> | undefined;
+  adapter: (ctx: GenericCtx<DataModel>, getAuthOptions: (ctx: any) => BetterAuthOptions) => better_auth_adapters0.AdapterFactory<BetterAuthOptions>;
+};
+//#endregion
+//#region src/auth/generated-contract-disabled.d.ts
+type GeneratedAuthDisabledReasonKind = 'default_export_unavailable' | 'missing_auth_file' | 'missing_default_export';
+declare const getGeneratedAuthDisabledReason: (kind: GeneratedAuthDisabledReasonKind, authDefinitionPath?: string) => string;
+type AuthRuntime<DataModel extends GenericDataModel, Schema extends SchemaDefinition<GenericSchema, true>, TriggerCtx extends GenericMutationCtx<DataModel> = GenericMutationCtx<DataModel>, GenericCtx = GenericMutationCtx<DataModel>, AuthOptions extends BetterAuthOptionsWithoutDatabase = BetterAuthOptionsWithoutDatabase> = {
+  auth: Auth<AuthOptions & {
+    database: BetterAuthOptions['database'];
+  }>;
+  authClient: ReturnType<typeof createClient<DataModel, Schema, TriggerCtx>>;
+  authEnabled: boolean;
+  getAuth: (ctx: GenericCtx) => Auth<AuthOptions & {
+    database: BetterAuthOptions['database'];
+  }>;
+} & ReturnType<typeof createApi<Schema, DataModel, GenericCtx, TriggerCtx, Auth<AuthOptions & {
+  database: BetterAuthOptions['database'];
+}>>>;
+declare const createDisabledAuthRuntime: <DataModel extends GenericDataModel, Schema extends SchemaDefinition<GenericSchema, true>, TriggerCtx extends GenericMutationCtx<DataModel> = GenericMutationCtx<DataModel>, GenericCtx = GenericMutationCtx<DataModel>, AuthOptions extends BetterAuthOptionsWithoutDatabase = BetterAuthOptionsWithoutDatabase>(config?: {
+  reason?: string;
+}) => AuthRuntime<DataModel, Schema, TriggerCtx, GenericCtx, AuthOptions>;
+//#endregion
+export { defineAuth as S, GenericAuthBeforeResult as _, AuthFunctions as a, GenericAuthTriggerHandlers as b, createApi as c, deleteOneHandler as d, findManyHandler as f, BetterAuthOptionsWithoutDatabase as g, updateOneHandler as h, getGeneratedAuthDisabledReason as i, createHandler as l, updateManyHandler as m, GeneratedAuthDisabledReasonKind as n, Triggers as o, findOneHandler as p, createDisabledAuthRuntime as r, createClient as s, AuthRuntime as t, deleteManyHandler as u, GenericAuthDefinition as v, GenericAuthTriggers as x, GenericAuthTriggerChange as y };

package/dist/http-types-DqJubRPJ.d.ts

@@ -0,0 +1,292 @@
+import { o as Simplify } from "./types-BTb_4BaU.js";
+import { m as UnsetMarker, t as AnyMiddleware } from "./types-DEJpkIhw.js";
+import { GenericActionCtx, GenericDataModel, HttpRouter } from "convex/server";
+import { z } from "zod";
+import { Context, Hono } from "hono";
+
+//#region src/crpc/transformer.d.ts
+/**
+ * Generic transformer contract (mirrors tRPC shape).
+ */
+interface DataTransformer {
+  deserialize(object: any): any;
+  serialize(object: any): any;
+}
+/**
+ * Separate input/output transformers.
+ */
+interface CombinedDataTransformer {
+  input: DataTransformer;
+  output: DataTransformer;
+}
+/**
+ * Transformer config accepted by cRPC.
+ */
+type DataTransformerOptions = CombinedDataTransformer | DataTransformer;
+/**
+ * Extensible tagged wire codec.
+ */
+interface WireCodec {
+  decode(value: unknown): unknown;
+  encode(value: unknown): unknown;
+  isType(value: unknown): boolean;
+  readonly tag: `$${string}`;
+}
+/**
+ * Date wire tag (Convex-style reserved key).
+ */
+declare const DATE_CODEC_TAG = "$date";
+/**
+ * Built-in Date codec.
+ */
+declare const dateWireCodec: WireCodec;
+/**
+ * Build a recursive tagged transformer from codecs.
+ */
+declare const createTaggedTransformer: (codecs: readonly WireCodec[]) => DataTransformer;
+/**
+ * Default cRPC transformer (Date-enabled).
+ */
+declare const defaultCRPCTransformer: DataTransformer;
+/**
+ * Normalize transformer config to split input/output shape.
+ * User transformers are additive and always composed with default Date handling.
+ */
+declare const getTransformer: (transformer?: DataTransformerOptions) => CombinedDataTransformer;
+/**
+ * Encode request payloads (input direction).
+ */
+declare const encodeWire: (value: unknown, transformer?: DataTransformerOptions) => unknown;
+/**
+ * Decode response payloads (output direction).
+ */
+declare const decodeWire: (value: unknown, transformer?: DataTransformerOptions) => unknown;
+/**
+ * Exposed identity transformer for advanced composition.
+ */
+declare const identityTransformer: CombinedDataTransformer;
+//#endregion
+//#region src/server/http-types.d.ts
+type ProcedureMeta = object;
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+interface HttpRouteDefinition<TMethod extends HttpMethod = HttpMethod> {
+  method: TMethod;
+  path: string;
+  pathParamNames: string[];
+  usePathPrefix: boolean;
+}
+/**
+ * Infer output type from schema, defaulting to void for UnsetMarker
+ */
+type InferHttpInput$1<T> = T extends UnsetMarker ? undefined : T extends z.ZodTypeAny ? z.output<T> : never;
+/**
+ * Internal definition for HttpProcedureBuilder
+ * Stores schema types directly (like QueryProcedureBuilder)
+ */
+interface HttpProcedureBuilderDef<TCtx, TInput extends UnsetMarker | z.ZodTypeAny, TOutput extends UnsetMarker | z.ZodTypeAny, TParams extends UnsetMarker | z.ZodTypeAny, TQuery extends UnsetMarker | z.ZodTypeAny, TMeta extends ProcedureMeta, TMethod extends HttpMethod = HttpMethod, TForm extends UnsetMarker | z.ZodTypeAny = UnsetMarker> {
+  /** @internal Phantom types for type inference */
+  _types?: {
+    input: TInput;
+    output: TOutput;
+    params: TParams;
+    query: TQuery;
+    form: TForm;
+  };
+  formSchema?: z.ZodTypeAny;
+  functionConfig: {
+    base: HttpActionConstructor;
+    createContext: (ctx: GenericActionCtx<GenericDataModel>) => TCtx;
+    transformer: CombinedDataTransformer;
+  };
+  inputSchema?: z.ZodTypeAny;
+  meta: TMeta;
+  middlewares: AnyMiddleware[];
+  outputSchema?: z.ZodTypeAny;
+  paramsSchema?: z.ZodTypeAny;
+  querySchema?: z.ZodTypeAny;
+  route?: HttpRouteDefinition<TMethod>;
+}
+type HttpActionConstructor = (handler: (ctx: GenericActionCtx<GenericDataModel>, request: Request) => Promise<Response>) => HttpActionHandler;
+interface HttpActionHandler {
+  isHttp: true;
+}
+interface HttpProcedure<TInput extends UnsetMarker | z.ZodTypeAny = any, TOutput extends UnsetMarker | z.ZodTypeAny = any, TParams extends UnsetMarker | z.ZodTypeAny = any, TQuery extends UnsetMarker | z.ZodTypeAny = any, TMethod extends HttpMethod = HttpMethod, TForm extends UnsetMarker | z.ZodTypeAny = any> extends HttpActionHandler {
+  _crpcHttpRoute: HttpRouteDefinition<TMethod>;
+  /** @internal Expose def for client-side type inference */
+  _def: {
+    inputSchema?: TInput;
+    outputSchema?: TOutput;
+    paramsSchema?: TParams;
+    querySchema?: TQuery;
+    formSchema?: TForm;
+  };
+}
+/**
+ * Handler options with ctx namespace (consistent with cRPC queries/mutations).
+ * - ctx: context properties (userId, db, runQuery, etc.)
+ * - input: parsed JSON body
+ * - params: parsed path params
+ * - searchParams: parsed query params
+ * - form: parsed form data
+ * - c: Hono Context for Response helpers (c.json, c.text, c.redirect, c.header, c.req)
+ */
+type HttpHandlerOpts<TCtx, TInput extends UnsetMarker | z.ZodTypeAny, TParams extends UnsetMarker | z.ZodTypeAny, TSearchParams extends UnsetMarker | z.ZodTypeAny, TForm extends UnsetMarker | z.ZodTypeAny> = {
+  ctx: TCtx;
+  c: Context;
+} & (TInput extends UnsetMarker ? object : {
+  input: z.output<TInput>;
+}) & (TParams extends UnsetMarker ? object : {
+  params: z.output<TParams>;
+}) & (TSearchParams extends UnsetMarker ? object : {
+  searchParams: z.output<TSearchParams>;
+}) & (TForm extends UnsetMarker ? object : {
+  form: z.output<TForm>;
+});
+/**
+ * Hono handler with cRPC route metadata attached
+ */
+interface CRPCHonoHandler {
+  _crpcRoute: {
+    path: string;
+    method: HttpMethod;
+  };
+  (c: Context): Promise<Response>;
+}
+//#endregion
+//#region src/server/http-router.d.ts
+/**
+ * Recursive router record - can contain procedures or nested routers
+ */
+interface HttpRouterRecord {
+  [key: string]: HttpProcedure | HttpRouterRecord | CRPCHttpRouter<any>;
+}
+/**
+ * Router definition - stores both flat procedures and hierarchical record
+ */
+interface HttpRouterDef<TRecord extends HttpRouterRecord> {
+  /** Flat map with dot-notation keys (e.g., "todos.get") for lookup */
+  procedures: Record<string, HttpProcedure>;
+  /** Hierarchical structure for type inference */
+  record: TRecord;
+  router: true;
+}
+/**
+ * HTTP Router - like tRPC's BuiltRouter
+ */
+interface CRPCHttpRouter<TRecord extends HttpRouterRecord> {
+  _def: HttpRouterDef<TRecord>;
+}
+/**
+ * HTTP Router that wraps a Hono app for use with Convex.
+ * Internal class - use `createHttpRouter()` factory instead.
+ */
+declare class HttpRouterWithHono extends HttpRouter {
+  private _app;
+  private _handler;
+  constructor(app: Hono);
+}
+/**
+ * Create a router factory function (like tRPC's createRouterFactory)
+ *
+ * @example
+ * ```ts
+ * // In crpc.ts
+ * export const router = c.router;
+ *
+ * // In api/todos.ts
+ * export const todosRouter = router({
+ *   get: publicRoute.get('/api/todos/:id')...,
+ *   create: authRoute.post('/api/todos')...,
+ * });
+ *
+ * // In http.ts
+ * export const httpRouter = router({
+ *   todos: todosRouter,
+ *   health,
+ * });
+ * export type AppRouter = typeof httpRouter;
+ * ```
+ */
+declare function createHttpRouterFactory(): <TRecord extends HttpRouterRecord>(record: TRecord) => CRPCHttpRouter<TRecord>;
+/**
+ * Create an HTTP router with cRPC routes registered.
+ *
+ * @example
+ * ```ts
+ * import { Hono } from 'hono';
+ * import { cors } from 'hono/cors';
+ * import { createHttpRouter } from 'kitcn/server';
+ *
+ * const app = new Hono();
+ * app.use('/api/*', cors({ origin: process.env.SITE_URL, credentials: true }));
+ *
+ * export default createHttpRouter(app, httpRouter);
+ * ```
+ */
+declare function createHttpRouter<TRecord extends HttpRouterRecord>(app: Hono, router: CRPCHttpRouter<TRecord>): HttpRouterWithHono;
+/**
+ * Extract route map from procedures for client runtime
+ *
+ * @example
+ * ```ts
+ * export const httpRoutes = extractRouteMap(httpRouter._def.procedures);
+ * ```
+ */
+declare function extractRouteMap<T extends Record<string, HttpProcedure>>(procedures: T): { [K in keyof T]: {
+  path: string;
+  method: string;
+} };
+//#endregion
+//#region src/crpc/http-types.d.ts
+/** Route definition for client runtime */
+type HttpRouteInfo = {
+  path: string;
+  method: string;
+};
+/** Route map type - from codegen */
+type HttpRouteMap = Record<string, HttpRouteInfo>;
+/** Infer schema type or return empty object if UnsetMarker */
+type InferSchemaOrEmpty<T> = T extends UnsetMarker ? object : T extends z.ZodTypeAny ? z.infer<T> : object;
+/**
+ * Infer merged input from HttpProcedure
+ * Combines params, query, and body input into a single object
+ */
+type InferHttpInput<T> = T extends HttpProcedure<infer TInput, infer _TOutput, infer TParams, infer TQuery> ? Simplify<InferSchemaOrEmpty<TParams> & InferSchemaOrEmpty<TQuery> & InferSchemaOrEmpty<TInput>> : object;
+/**
+ * Infer output type from HttpProcedure
+ */
+type InferHttpOutput<T> = T extends HttpProcedure<infer _TInput, infer TOutput, infer _TParams, infer _TQuery> ? TOutput extends UnsetMarker ? unknown : TOutput extends z.ZodTypeAny ? z.infer<TOutput> : unknown : unknown;
+/**
+ * Single procedure call signature
+ * Returns a function that takes merged input and returns output
+ */
+type HttpProcedureCall<T extends HttpProcedure> = keyof InferHttpInput<T> extends never ? () => Promise<InferHttpOutput<T>> : object extends InferHttpInput<T> ? (input?: InferHttpInput<T>) => Promise<InferHttpOutput<T>> : (input: InferHttpInput<T>) => Promise<InferHttpOutput<T>>;
+/**
+ * HTTP Client type from router record
+ * Maps each procedure to its call signature, recursively for nested routers
+ */
+type HttpClient<T extends HttpRouterRecord> = { [K in keyof T]: T[K] extends HttpProcedure ? HttpProcedureCall<T[K]> : T[K] extends CRPCHttpRouter<infer R> ? HttpClient<R> : T[K] extends HttpRouterRecord ? HttpClient<T[K]> : never };
+/**
+ * HTTP Client type from a CRPCHttpRouter
+ * Use this when your type is the router object (with _def)
+ */
+type HttpClientFromRouter<TRouter extends CRPCHttpRouter<any>> = HttpClient<TRouter['_def']['record']>;
+/** Error codes that can be returned from HTTP endpoints */
+type HttpErrorCode = 'BAD_REQUEST' | 'UNAUTHORIZED' | 'FORBIDDEN' | 'NOT_FOUND' | 'METHOD_NOT_SUPPORTED' | 'CONFLICT' | 'UNPROCESSABLE_CONTENT' | 'TOO_MANY_REQUESTS' | 'INTERNAL_SERVER_ERROR' | 'UNKNOWN';
+/** HTTP client error */
+declare class HttpClientError extends Error {
+  readonly name = "HttpClientError";
+  readonly code: HttpErrorCode;
+  readonly status: number;
+  readonly procedureName: string;
+  constructor(opts: {
+    code: HttpErrorCode;
+    status: number;
+    procedureName: string;
+    message?: string;
+  });
+}
+/** Type guard for HttpClientError */
+declare const isHttpClientError: (error: unknown) => error is HttpClientError;
+//#endregion
+export { DataTransformer as A, HttpProcedure as C, ProcedureMeta as D, InferHttpInput$1 as E, decodeWire as F, defaultCRPCTransformer as I, encodeWire as L, WireCodec as M, createTaggedTransformer as N, CombinedDataTransformer as O, dateWireCodec as P, getTransformer as R, HttpMethod as S, HttpRouteDefinition as T, extractRouteMap as _, HttpProcedureCall as a, HttpActionHandler as b, InferHttpInput as c, CRPCHttpRouter as d, HttpRouterDef as f, createHttpRouterFactory as g, createHttpRouter as h, HttpErrorCode as i, DataTransformerOptions as j, DATE_CODEC_TAG as k, InferHttpOutput as l, HttpRouterWithHono as m, HttpClientError as n, HttpRouteInfo as o, HttpRouterRecord as p, HttpClientFromRouter as r, HttpRouteMap as s, HttpClient as t, isHttpClientError as u, CRPCHonoHandler as v, HttpProcedureBuilderDef as w, HttpHandlerOpts as x, HttpActionConstructor as y, identityTransformer as z };