cvx-kit 0.0.3 → 0.0.4

package/dist/components/approvals/audit.mjs

@@ -1,2 +1,2 @@
-import{components as e}from"./_generated/api.mjs";import{mutation as t,query as n}from"./_generated/server.mjs";import{APPROVAL_AUDIT_RETENTION_CATEGORY as r,MAX_APPROVAL_AUDIT_RETENTION_DAYS as i}from"./constants.mjs";import{v as a}from"convex/values";import{AuditLog as o}from"convex-audit-log";const s=new o(e.auditLog,{samplingEnabled:!1}),c=n({args:{resourceType:a.string(),resourceRef:a.string(),limit:a.optional(a.number())},returns:a.array(a.object({action:a.string(),actorRef:a.optional(a.string()),correlationKey:a.string(),transition:a.string()})),handler:async(e,t)=>{let n=Math.max(1,Math.min(Math.trunc(t.limit??100),100)),r=await s.queryByResource(e,{resourceType:t.resourceType,resourceId:t.resourceRef,limit:n}),i=new Map;for(let e of r){let t=p(e);t&&i.set(t.correlationKey,t)}return[...i.values()]}}),l=t({args:{olderThanDays:a.number(),batchSize:a.number()},returns:a.number(),handler:(e,t)=>{let n=f(t.olderThanDays,1,i,`olderThanDays`),a=f(t.batchSize,1,100,`batchSize`);return s.cleanup(e,{olderThanDays:n,batchSize:a,retentionCategory:r})}});function u(e){return{action:e.action,...e.actorRef===void 0?{}:{actorId:e.actorRef},resourceType:e.resourceType,resourceId:e.resourceRef,severity:e.severity??`info`,tags:[`approvals`],retentionCategory:r,metadata:{correlationKey:`${e.runId}:${e.transition}`,runId:e.runId,transition:e.transition}}}async function d(e,t){await s.log(e,u(t))}function f(e,t,n,r){if(!Number.isInteger(e)||e<t||e>n)throw Error(`${r} must be an integer between ${t} and ${n}`);return e}function p(e){if(!e||typeof e!=`object`)return null;let t=e,n=t.metadata;if(!n||typeof n!=`object`)return null;let r=n;return typeof t.action!=`string`||typeof r.correlationKey!=`string`||typeof r.transition!=`string`?null:{action:t.action,...typeof t.actorId==`string`?{actorRef:t.actorId}:{},correlationKey:r.correlationKey,transition:r.transition}}export{s as approvalAudit,u as approvalAuditEvent,l as cleanup,c as history,d as logApprovalTransition};
+import{components as e}from"./_generated/api.mjs";import{mutation as t,query as n}from"./_generated/server.mjs";import{APPROVAL_AUDIT_RETENTION_CATEGORY as r,MAX_APPROVAL_AUDIT_RETENTION_DAYS as i}from"./constants.mjs";import{AuditLog as a}from"convex-audit-log";import{v as o}from"convex/values";const s=new a(e.auditLog,{samplingEnabled:!1}),c=n({args:{resourceType:o.string(),resourceRef:o.string(),limit:o.optional(o.number())},returns:o.array(o.object({action:o.string(),actorRef:o.optional(o.string()),correlationKey:o.string(),transition:o.string()})),handler:async(e,t)=>{let n=Math.max(1,Math.min(Math.trunc(t.limit??100),100)),r=await s.queryByResource(e,{resourceType:t.resourceType,resourceId:t.resourceRef,limit:n}),i=new Map;for(let e of r){let t=p(e);t&&i.set(t.correlationKey,t)}return[...i.values()]}}),l=t({args:{olderThanDays:o.number(),batchSize:o.number()},returns:o.number(),handler:(e,t)=>{let n=f(t.olderThanDays,1,i,`olderThanDays`),a=f(t.batchSize,1,100,`batchSize`);return s.cleanup(e,{olderThanDays:n,batchSize:a,retentionCategory:r})}});function u(e){return{action:e.action,...e.actorRef===void 0?{}:{actorId:e.actorRef},resourceType:e.resourceType,resourceId:e.resourceRef,severity:e.severity??`info`,tags:[`approvals`],retentionCategory:r,metadata:{correlationKey:`${e.runId}:${e.transition}`,runId:e.runId,transition:e.transition}}}async function d(e,t){await s.log(e,u(t))}function f(e,t,n,r){if(!Number.isInteger(e)||e<t||e>n)throw Error(`${r} must be an integer between ${t} and ${n}`);return e}function p(e){if(!e||typeof e!=`object`)return null;let t=e,n=t.metadata;if(!n||typeof n!=`object`)return null;let r=n;return typeof t.action!=`string`||typeof r.correlationKey!=`string`||typeof r.transition!=`string`?null:{action:t.action,...typeof t.actorId==`string`?{actorRef:t.actorId}:{},correlationKey:r.correlationKey,transition:r.transition}}export{s as approvalAudit,u as approvalAuditEvent,l as cleanup,c as history,d as logApprovalTransition};
 //# sourceMappingURL=audit.mjs.map

package/package.json

@@ -1,16 +1,10 @@
 {
 	"name": "cvx-kit",
-	"version": "0.0.3",
+	"version": "0.0.4",
 	"description": "Reusable Convex application kit: foundation kernels, approvals component, zod table boundaries, WorkOS-backed auth function constructors, and audited command protocol.",
 	"type": "module",
 	"license": "MIT",
 	"sideEffects": false,
-	"files": [
-		"dist",
-		"src",
-		"!src/docs",
-		"docs"
-	],
 	"exports": {
 		"./package.json": "./package.json",
 		".": {
@@ -74,7 +68,7 @@
 		"typecheck": "tsc --noEmit",
 		"test": "vp test run",
 		"docs:sync": "rm -f docs/*.md && cp src/docs/*.md docs/",
-		"prepublishOnly": "bun run typecheck && bun run test && bun run build && bun run docs:sync",
+		"prepublishOnly": "bun run build && bun run typecheck && bun run test && bun run docs:sync",
 		"build:codegen": "convex codegen --component-dir ./src/components/foundation && convex codegen --component-dir ./src/components/approvals && vp pack",
 		"release": "npm version patch && git push --follow-tags",
 		"release:minor": "npm version minor && git push --follow-tags"

package/src/test.ts

@@ -2,16 +2,18 @@
  * Test helpers for consumers, following the official component template:
  * register the kit's components on a convex-test instance so host-app tests
  * run against them in-memory. Requires a vitest-compatible runner
- * (import.meta.glob), which is why this export ships as source.
+ * (import.meta.glob), which is why this file ships as source — but it
+ * registers the COMPILED component modules from dist, so dist is the only
+ * code the package ships.
  */
-import approvalsSchema from './components/approvals/schema'
-import foundationSchema from './components/foundation/schema'
+import approvalsSchema from '../dist/components/approvals/schema.mjs'
+import foundationSchema from '../dist/components/foundation/schema.mjs'
 
 const foundationModules = import.meta.glob(
-	'./components/foundation/**/!(*.test).ts',
+	'../dist/components/foundation/**/*.mjs',
 )
 const approvalsModules = import.meta.glob(
-	'./components/approvals/**/!(*.test).ts',
+	'../dist/components/approvals/**/*.mjs',
 )
 
 type RegistersComponents = {

package/src/auth.ts

@@ -1,473 +0,0 @@
-import {
-	zCustomAction,
-	zCustomMutation,
-	zCustomQuery,
-} from 'convex-helpers/server/zod4'
-import type {
-	ActionBuilder,
-	DocumentByInfo,
-	GenericActionCtx,
-	GenericDataModel,
-	GenericMutationCtx,
-	GenericQueryCtx,
-	GenericTableInfo,
-	IndexNames,
-	IndexRange,
-	IndexRangeBuilder,
-	MutationBuilder,
-	NamedIndex,
-	Query,
-	QueryBuilder,
-	QueryInitializer,
-	UserIdentity,
-} from 'convex/server'
-import type { Triggers } from 'convex-helpers/server/triggers'
-import type { TableNamesInDataModel } from 'convex/server'
-import { defaultErrors, type ErrorFactory } from './errors'
-import {
-	composeRules,
-	createTenantRules,
-	wrapDatabaseReader,
-	wrapDatabaseWriter,
-	type RLSConfig,
-	type Rules,
-} from './tenancy'
-
-/** The default vocabulary; every app can supply its own via the Role generic. */
-export type DefaultRole = 'reader' | 'writer' | 'admin'
-
-export type Actor<Role extends string> = Readonly<{
-	userId: string
-	organizationId: string
-	role: Role
-}>
-
-export type AuthBundle<Role extends string> = Readonly<{
-	identity: UserIdentity
-	user: Readonly<{ id: string }>
-	org: Readonly<{ organizationId: string; role: Role }>
-	role: Role
-	actor: Actor<Role>
-	/** The resolved tenant — security.tenancy.resolve, or the organization id. */
-	tenant: string
-}>
-
-/**
- * Row-level security configuration. Tenant isolation and role-level rules
- * compose (AND) onto the same wrapped database: queries get a wrapped
- * reader, mutations get triggers first, then a wrapped writer.
- */
-export type SecurityConfig<
-	DataModel extends GenericDataModel,
-	Role extends string,
-> = {
-	/**
-	 * Tenant isolation. `tables` is THE registry: every listed table gets
-	 * read/insert/modify gated on row.tenant === ctx.tenant. Pair with
-	 * tenantTable (schema) and tenantOwnership (triggers) on the same list.
-	 */
-	tenancy?: {
-		tables: readonly TableNamesInDataModel<DataModel>[]
-		/** Maps the auth bundle to the tenant; defaults to org.organizationId. */
-		resolve?: (bundle: Omit<AuthBundle<Role>, 'tenant'>) => string
-	}
-	/**
-	 * Role-level (or any policy) rules derived from the authenticated bundle,
-	 * composed AND-wise with tenant isolation. E.g. gate `modify` on a table
-	 * to admin roles.
-	 */
-	rules?: (bundle: AuthBundle<Role>) => Rules<unknown, DataModel>
-	/**
-	 * Policy for tables with no rule. Defaults to 'deny' when tenancy is
-	 * configured (unlisted tables are unreachable — fail closed), 'allow'
-	 * otherwise.
-	 */
-	defaultPolicy?: RLSConfig['defaultPolicy']
-}
-
-type AnyAuthContext<DataModel extends GenericDataModel> =
-	| GenericQueryCtx<DataModel>
-	| GenericMutationCtx<DataModel>
-	| GenericActionCtx<DataModel>
-
-export type AuthFunctionsConfig<
-	DataModel extends GenericDataModel,
-	Role extends string,
-> = {
-	/** The consumer's generated function builders (from ./_generated/server). */
-	query: QueryBuilder<DataModel, 'public'>
-	mutation: MutationBuilder<DataModel, 'public'>
-	action: ActionBuilder<DataModel, 'public'>
-	internalMutation: MutationBuilder<DataModel, 'internal'>
-	internalAction: ActionBuilder<DataModel, 'internal'>
-	/** Resolves the synchronized principal, e.g. (ctx) => authKit.getAuthUser(ctx). */
-	getAuthUser: (
-		ctx: AnyAuthContext<DataModel>,
-	) => Promise<{ id: string } | null>
-	/**
-	 * Maps an identity role slug onto the app's role vocabulary. Returning
-	 * null rejects the caller with FORBIDDEN — unknown roles never pass.
-	 */
-	mapRole: (roleSlug?: string) => Role | null
-	/** Roles allowed through the admin* constructors. */
-	adminRoles: readonly NoInfer<Role>[]
-	/**
-	 * Live membership check for actions (queries/mutations trust the JWT).
-	 * Authentication fails closed with FORBIDDEN when verification errors.
-	 * Omit to let actions trust the JWT like queries do.
-	 */
-	verifyMembership?: (input: {
-		userId: string
-		organizationId: string
-	}) => Promise<{ organizationId: string; roleSlug: string } | null>
-	/** Host error policy; defaults to throwing KitError. */
-	errors?: ErrorFactory
-	/**
-	 * Application trigger registry. When set, every authMutation,
-	 * roleMutation, and systemMutation write runs through triggers.wrapDB —
-	 * evaluations registered on tables fire structurally.
-	 */
-	triggers?: Triggers<DataModel>
-	/** Lower-level alternative to `triggers`: a custom ctx wrapper. */
-	wrapDB?: (
-		ctx: GenericMutationCtx<DataModel>,
-	) => GenericMutationCtx<DataModel>
-	/** Upper bound for include() reads. */
-	maxIncludedQueryRows?: number
-	/**
-	 * Row-level security: tenant isolation (from a table registry) and
-	 * role-level rules, applied structurally inside every auth*, role*, and
-	 * admin* constructor. system* constructors stay unwrapped (trusted).
-	 */
-	security?: SecurityConfig<DataModel, Role>
-}
-
-/** WorkOS-style default: `member` writes; reader/writer/admin pass through. */
-export function defaultRoleMap(roleSlug?: string): DefaultRole | null {
-	const normalized = roleSlug?.trim().toLowerCase()
-	if (normalized === 'member') return 'writer'
-	return normalized === 'reader' ||
-		normalized === 'writer' ||
-		normalized === 'admin'
-		? normalized
-		: null
-}
-
-export type IncludedQuery<Table extends GenericTableInfo> = {
-	when<Value>(
-		value: Value | null | undefined,
-		select: (query: QueryInitializer<Table>, value: Value) => Query<Table>,
-	): IncludedQuery<Table>
-	matching<IndexName extends IndexNames<Table>>(
-		indexName: IndexName,
-		indexRange?: (
-			query: IndexRangeBuilder<
-				DocumentByInfo<Table>,
-				NamedIndex<Table, IndexName>
-			>,
-		) => IndexRange,
-		shouldMatch?: boolean,
-	): IncludedQuery<Table>
-	otherwise(
-		select: (query: QueryInitializer<Table>) => Query<Table>,
-	): Query<Table>
-	resolve(): Query<Table>
-	execute<Result = Awaited<ReturnType<Query<Table>['take']>>>(
-		limit: number,
-		transform?: (
-			data: Awaited<ReturnType<Query<Table>['take']>>,
-		) => Result | Promise<Result>,
-	): Promise<Result>
-}
-
-export type Include = <Table extends GenericTableInfo>(
-	query: QueryInitializer<Table>,
-) => IncludedQuery<Table>
-
-/** Builds an include() that selects the first matching indexed query and bounds the read. */
-export function createInclude(options?: {
-	errors?: ErrorFactory
-	maxRows?: number
-}): Include {
-	const errors = options?.errors ?? defaultErrors
-	const maxRows = options?.maxRows ?? 100
-
-	function attach<Table extends GenericTableInfo>(
-		query: QueryInitializer<Table>,
-		selected?: Query<Table>,
-	): IncludedQuery<Table> {
-		return {
-			when: (value, select) =>
-				selected || value === undefined || value === null
-					? attach(query, selected)
-					: attach(query, select(query, value)),
-			matching: (indexName, indexRange, shouldMatch = true) =>
-				selected || !shouldMatch
-					? attach(query, selected)
-					: attach(query, query.withIndex(indexName, indexRange)),
-			otherwise: (select) => selected ?? select(query),
-			resolve: () => selected ?? query.fullTableScan(),
-			execute: async (limit, transform) => {
-				if (!Number.isSafeInteger(limit) || limit < 1 || limit > maxRows) {
-					return errors.throw({
-						code: 'INVALID_REQUEST_BOUNDARY',
-						message: `A bounded query limit must be from 1 to ${maxRows}`,
-					})
-				}
-				const data = await (selected ?? query.fullTableScan()).take(limit)
-				return transform ? transform(data) : (data as never)
-			},
-		}
-	}
-
-	return (query) => attach(query)
-}
-
-/**
- * Builds the auth-aware function constructors from the host's injected
- * policy: identity resolution, the app's own role vocabulary, live
- * membership verification for actions, trigger wrapping for mutations,
- * and errors. Role-based access is first-class — every constructor family
- * has a role-gated variant (roleQuery/roleMutation/roleAction), and the
- * admin* constructors are just that gate applied to config.adminRoles.
- */
-export function createAuthFunctions<
-	DataModel extends GenericDataModel,
-	const Role extends string = DefaultRole,
->(config: AuthFunctionsConfig<DataModel, Role>) {
-	const errors = config.errors ?? defaultErrors
-	const wrapDB = config.triggers
-		? (ctx: GenericMutationCtx<DataModel>) =>
-				(config.triggers as Triggers<DataModel>).wrapDB(ctx)
-		: (config.wrapDB ?? ((ctx) => ctx))
-	const include = createInclude({
-		errors,
-		maxRows: config.maxIncludedQueryRows,
-	})
-
-	async function authenticatedUser(
-		ctx: AnyAuthContext<DataModel>,
-	): Promise<AuthBundle<Role>> {
-		const identity = await ctx.auth.getUserIdentity()
-		const user = identity ? await config.getAuthUser(ctx) : null
-		if (!identity || !user) return errors.throw({ code: 'UNAUTHENTICATED' })
-		const organization = identity.organization
-		const organizationId =
-			organization &&
-			typeof organization === 'object' &&
-			'organizationId' in organization &&
-			typeof organization.organizationId === 'string'
-				? organization.organizationId
-				: typeof identity.org_id === 'string'
-					? identity.org_id
-					: null
-		if (!organizationId) return errors.throw({ code: 'UNAUTHENTICATED' })
-		const organizationRole =
-			organization &&
-			typeof organization === 'object' &&
-			'role' in organization &&
-			typeof organization.role === 'string'
-				? organization.role
-				: typeof identity.role === 'string'
-					? identity.role
-					: undefined
-		const role = config.mapRole(organizationRole)
-		if (!role) return errors.throw({ code: 'FORBIDDEN' })
-		const base = {
-			identity,
-			user: Object.freeze({ id: user.id }),
-			org: Object.freeze({ organizationId, role }),
-			role,
-			actor: Object.freeze({ userId: user.id, organizationId, role }),
-		}
-		return Object.freeze({
-			...base,
-			tenant: config.security?.tenancy?.resolve?.(base) ?? organizationId,
-		})
-	}
-
-	const securityConfig: RLSConfig | undefined = config.security
-		? {
-				defaultPolicy:
-					config.security.defaultPolicy ??
-					(config.security.tenancy ? 'deny' : 'allow'),
-			}
-		: undefined
-
-	function securityRules(
-		bundle: AuthBundle<Role>,
-	): Rules<unknown, DataModel> | undefined {
-		const security = config.security
-		if (!security) return undefined
-		const sets: Rules<unknown, DataModel>[] = []
-		if (security.tenancy) {
-			sets.push(
-				createTenantRules<DataModel>(bundle.tenant, security.tenancy.tables),
-			)
-		}
-		if (security.rules) sets.push(security.rules(bundle))
-		return sets.length === 1 ? sets[0] : composeRules(...sets)
-	}
-
-	function secureReader(
-		ctx: GenericQueryCtx<DataModel>,
-		bundle: AuthBundle<Role>,
-	): GenericQueryCtx<DataModel> {
-		const rules = securityRules(bundle)
-		if (!rules) return ctx
-		return {
-			...ctx,
-			db: wrapDatabaseReader({}, ctx.db, rules as never, securityConfig),
-		}
-	}
-
-	function secureWriter(
-		ctx: GenericMutationCtx<DataModel>,
-		bundle: AuthBundle<Role>,
-	): GenericMutationCtx<DataModel> {
-		const rules = securityRules(bundle)
-		if (!rules) return ctx
-		// Triggers wrap first (ctx already trigger-wrapped by the caller),
-		// then row-level security wraps the triggered db — order matters.
-		return {
-			...ctx,
-			db: wrapDatabaseWriter({}, ctx.db, rules as never, securityConfig),
-		}
-	}
-
-	async function verifiedMembership(userId: string, organizationId: string) {
-		if (!config.verifyMembership) return null
-		try {
-			const membership = await config.verifyMembership({
-				userId,
-				organizationId,
-			})
-			if (membership && membership.organizationId === organizationId) {
-				return membership
-			}
-		} catch {
-			// Authentication fails closed when membership cannot be verified.
-		}
-		return errors.throw({ code: 'FORBIDDEN' })
-	}
-
-	function requireRole(role: Role, allowed: readonly Role[]) {
-		if (!allowed.includes(role)) return errors.throw({ code: 'FORBIDDEN' })
-	}
-
-	async function queryInput(ctx: GenericQueryCtx<DataModel>) {
-		const bundle = await authenticatedUser(ctx)
-		return {
-			ctx: { ...secureReader(ctx, bundle), include, ...bundle },
-			args: {},
-		}
-	}
-
-	async function mutationInput(ctx: GenericMutationCtx<DataModel>) {
-		const bundle = await authenticatedUser(ctx)
-		return {
-			ctx: { ...secureWriter(wrapDB(ctx), bundle), include, ...bundle },
-			args: {},
-		}
-	}
-
-	async function actionInput(ctx: GenericActionCtx<DataModel>) {
-		const authenticated = await authenticatedUser(ctx)
-		const membership = await verifiedMembership(
-			authenticated.user.id,
-			authenticated.org.organizationId,
-		)
-		if (!membership) return { ctx: { ...ctx, ...authenticated }, args: {} }
-		const role = config.mapRole(membership.roleSlug)
-		if (!role) return errors.throw({ code: 'FORBIDDEN' })
-		const verified = {
-			identity: authenticated.identity,
-			user: authenticated.user,
-			org: Object.freeze({
-				organizationId: membership.organizationId,
-				role,
-			}),
-			role,
-			actor: Object.freeze({
-				userId: authenticated.user.id,
-				organizationId: membership.organizationId,
-				role,
-			}),
-		}
-		return {
-			ctx: {
-				...ctx,
-				...verified,
-				// Tenant re-derives from the live-verified organization.
-				tenant:
-					config.security?.tenancy?.resolve?.(verified) ??
-					membership.organizationId,
-			},
-			args: {},
-		}
-	}
-
-	/** Query constructor allowing only the given roles. */
-	function roleQuery(...allowed: readonly Role[]) {
-		return zCustomQuery(config.query, {
-			args: {},
-			input: async (ctx) => {
-				const authenticated = await queryInput(ctx)
-				requireRole(authenticated.ctx.actor.role, allowed)
-				return authenticated
-			},
-		})
-	}
-
-	/** Mutation constructor allowing only the given roles. */
-	function roleMutation(...allowed: readonly Role[]) {
-		return zCustomMutation(config.mutation, {
-			args: {},
-			input: async (ctx) => {
-				const authenticated = await mutationInput(ctx)
-				requireRole(authenticated.ctx.actor.role, allowed)
-				return authenticated
-			},
-		})
-	}
-
-	/** Action constructor allowing only the given roles (post live verification). */
-	function roleAction(...allowed: readonly Role[]) {
-		return zCustomAction(config.action, {
-			args: {},
-			input: async (ctx) => {
-				const authenticated = await actionInput(ctx)
-				requireRole(authenticated.ctx.actor.role, allowed)
-				return authenticated
-			},
-		})
-	}
-
-	return {
-		include,
-		authenticatedUser,
-		roleQuery,
-		roleMutation,
-		roleAction,
-		authQuery: zCustomQuery(config.query, { args: {}, input: queryInput }),
-		authMutation: zCustomMutation(config.mutation, {
-			args: {},
-			input: mutationInput,
-		}),
-		authAction: zCustomAction(config.action, {
-			args: {},
-			input: actionInput,
-		}),
-		adminQuery: roleQuery(...config.adminRoles),
-		adminMutation: roleMutation(...config.adminRoles),
-		adminAction: roleAction(...config.adminRoles),
-		systemMutation: zCustomMutation(config.internalMutation, {
-			args: {},
-			input: async (ctx) => ({ ctx: { ...wrapDB(ctx), include }, args: {} }),
-		}),
-		systemAction: zCustomAction(config.internalAction, {
-			args: {},
-			input: async (ctx) => ({ ctx, args: {} }),
-		}),
-	}
-}

package/src/components/approvals/_generated/api.ts

@@ -1,69 +0,0 @@
-/* eslint-disable */
-/**
- * Generated `api` utility.
- *
- * THIS CODE IS AUTOMATICALLY GENERATED.
- *
- * To regenerate, run `npx convex dev`.
- * @module
- */
-
-import type * as audit from "../audit.js";
-import type * as client from "../client.js";
-import type * as constants from "../constants.js";
-import type * as decisions from "../decisions.js";
-import type * as functions from "../functions.js";
-import type * as requests from "../requests.js";
-import type * as validators from "../validators.js";
-import type * as workflow from "../workflow.js";
-import type * as workflow_steps from "../workflow_steps.js";
-
-import type {
-  ApiFromModules,
-  FilterApi,
-  FunctionReference,
-} from "convex/server";
-import { anyApi, componentsGeneric } from "convex/server";
-
-const fullApi: ApiFromModules<{
-  audit: typeof audit;
-  client: typeof client;
-  constants: typeof constants;
-  decisions: typeof decisions;
-  functions: typeof functions;
-  requests: typeof requests;
-  validators: typeof validators;
-  workflow: typeof workflow;
-  workflow_steps: typeof workflow_steps;
-}> = anyApi as any;
-
-/**
- * A utility for referencing Convex functions in your app's public API.
- *
- * Usage:
- * ```js
- * const myFunctionReference = api.myModule.myFunction;
- * ```
- */
-export const api: FilterApi<
-  typeof fullApi,
-  FunctionReference<any, "public">
-> = anyApi as any;
-
-/**
- * A utility for referencing Convex functions in your app's internal API.
- *
- * Usage:
- * ```js
- * const myFunctionReference = internal.myModule.myFunction;
- * ```
- */
-export const internal: FilterApi<
-  typeof fullApi,
-  FunctionReference<any, "internal">
-> = anyApi as any;
-
-export const components = componentsGeneric() as unknown as {
-  workflow: import("@convex-dev/workflow/_generated/component.js").ComponentApi<"workflow">;
-  auditLog: import("convex-audit-log/_generated/component.js").ComponentApi<"auditLog">;
-};