better-convex 0.7.3 → 0.8.1

package/dist/orm/index.js

@@ -1,6 +1,10 @@
-import { A as entityKind, C as text, D as custom, E as id, O as json, S as vectorIndex, T as integer, _ as aggregateIndex, a as deletion, b as searchIndex, c as EnableRLS, d as OrmSchemaOptions, f as RlsPolicies, g as rlsPolicy, h as RlsPolicy, i as convexTable, k as ConvexColumnBuilder, l as OrmContext, m as TableName, o as Brand, p as TableDeleteConfig, s as Columns, t as DirectAggregate, u as OrmSchemaDefinition, v as index, w as createSystemFields, x as uniqueIndex, y as rankIndex } from "../runtime-B9xQFY8W.js";
-import { a as pretendRequired, i as pretend, n as deprecated } from "../validators-B7oIJCAp.js";
-import { A as ne, C as inArray, D as like, E as isNull, F as notLike, I as or, L as startsWith, M as notBetween, N as notIlike, O as lt, P as notInArray, S as ilike, T as isNotNull, _ as endsWith, a as mergedStream, b as gt, c as isUnsetToken, d as arrayContained, f as arrayContains, g as contains, h as column, i as getIndexFields, j as not, k as lte, l as unsetToken, m as between, n as EmptyStream, o as stream, p as arrayOverlaps, r as QueryStream, s as streamIndexRange, t as getByIdWithOrmQueryFallback, u as and, v as eq, w as isFieldReference, x as gte, y as fieldRef } from "../query-context-yQVARct0.js";
+import { t as DirectAggregate } from "../runtime-C0WcYGY0.js";
+import { C as integer, S as createSystemFields, T as entityKind, _ as rankIndex, a as EnableRLS, b as vectorIndex, c as OrmSchemaOptions, d as TableDeleteConfig, f as TableName, g as index, h as aggregateIndex, i as Columns, l as OrmSchemaPluginTables, m as rlsPolicy, n as deletion, o as OrmContext, p as RlsPolicy, r as Brand, s as OrmSchemaDefinition, t as convexTable, u as RlsPolicies, v as searchIndex, w as ConvexColumnBuilder, x as text, y as uniqueIndex } from "../table-B7yzBihE.js";
+import { a as AGGREGATE_EXTREMA_TABLE, c as aggregatePlugin, i as AGGREGATE_BUCKET_TABLE, l as boolean, n as MIGRATION_STATE_TABLE, o as AGGREGATE_MEMBER_TABLE, r as migrationPlugin, s as AGGREGATE_STATE_TABLE, t as MIGRATION_RUN_TABLE } from "../schema-Bx6j2doh.js";
+import { a as pretendRequired, i as pretend, n as deprecated } from "../validators-D_i3BK7v.js";
+import { a as objectOf, i as json, n as arrayOf, r as custom, t as id } from "../id-BcBb900m.js";
+import { t as textEnum } from "../text-enum-CFdcLUuw.js";
+import { A as ne, C as inArray, D as like, E as isNull, F as notLike, I as or, L as startsWith, M as notBetween, N as notIlike, O as lt, P as notInArray, S as ilike, T as isNotNull, _ as endsWith, a as mergedStream, b as gt, c as isUnsetToken, d as arrayContained, f as arrayContains, g as contains, h as column, i as getIndexFields, j as not, k as lte, l as unsetToken, m as between, n as EmptyStream, o as stream, p as arrayOverlaps, r as QueryStream, s as streamIndexRange, t as getByIdWithOrmQueryFallback, u as and, v as eq, w as isFieldReference, x as gte, y as fieldRef } from "../query-context-DEUFBhXS.js";
 import { v } from "convex/values";
 import { defineSchema as defineSchema$1, internalActionGeneric, internalMutationGeneric } from "convex/server";
 
@@ -34,37 +38,6 @@ function bigint(name) {
 	return new ConvexBigIntBuilder(name ?? "");
 }
 
-//#endregion
-//#region src/orm/builders/boolean.ts
-/**
-* Boolean column builder class
-* Compiles to v.boolean() or v.optional(v.boolean())
-*/
-var ConvexBooleanBuilder = class extends ConvexColumnBuilder {
-	static [entityKind] = "ConvexBooleanBuilder";
-	constructor(name) {
-		super(name, "boolean", "ConvexBoolean");
-	}
-	/**
-	* Expose Convex validator for schema integration
-	*/
-	get convexValidator() {
-		if (this.config.notNull) return v.boolean();
-		return v.optional(v.union(v.null(), v.boolean()));
-	}
-	/**
-	* Compile to Convex validator
-	* .notNull() → v.boolean()
-	* nullable → v.optional(v.boolean())
-	*/
-	build() {
-		return this.convexValidator;
-	}
-};
-function boolean(name) {
-	return new ConvexBooleanBuilder(name ?? "");
-}
-
 //#endregion
 //#region src/orm/builders/bytes.ts
 var ConvexBytesBuilder = class extends ConvexColumnBuilder {
@@ -116,32 +89,6 @@ function date(nameOrConfig, maybeConfig) {
 	return new ConvexDateBuilder(name, mode);
 }
 
-//#endregion
-//#region src/orm/builders/text-enum.ts
-var ConvexTextEnumBuilder = class extends ConvexColumnBuilder {
-	static [entityKind] = "ConvexTextEnumBuilder";
-	constructor(name, values) {
-		super(name, "string", "ConvexText");
-		this.config.values = [...values];
-	}
-	_enumValidator() {
-		const literals = this.config.values.map((value) => v.literal(value));
-		if (literals.length === 1) return literals[0];
-		return v.union(...literals);
-	}
-	get convexValidator() {
-		const base = this._enumValidator();
-		if (this.config.notNull) return base;
-		return v.optional(v.union(v.null(), base));
-	}
-	build() {
-		return this.convexValidator;
-	}
-};
-function textEnum(values) {
-	return new ConvexTextEnumBuilder("", values);
-}
-
 //#endregion
 //#region src/orm/builders/timestamp.ts
 var ConvexTimestampBuilder = class extends ConvexColumnBuilder {
@@ -290,113 +237,6 @@ function check(name, expression) {
 	return new ConvexCheckBuilder(name, expression);
 }
 
-//#endregion
-//#region src/orm/aggregate-index/schema.ts
-const AGGREGATE_BUCKET_TABLE = "aggregate_bucket";
-const AGGREGATE_MEMBER_TABLE = "aggregate_member";
-const AGGREGATE_EXTREMA_TABLE = "aggregate_extrema";
-const AGGREGATE_RANK_TREE_TABLE = "aggregate_rank_tree";
-const AGGREGATE_RANK_NODE_TABLE = "aggregate_rank_node";
-const AGGREGATE_STATE_TABLE = "aggregate_state";
-const countBucketTable = convexTable(AGGREGATE_BUCKET_TABLE, {
-	tableKey: text().notNull(),
-	indexName: text().notNull(),
-	keyHash: text().notNull(),
-	keyParts: custom(v.array(v.any())).notNull(),
-	count: integer().notNull(),
-	sumValues: custom(v.record(v.string(), v.number())).notNull(),
-	nonNullCountValues: custom(v.record(v.string(), v.number())).notNull(),
-	updatedAt: integer().notNull()
-}, (t) => [index("by_table_index_hash").on(t.tableKey, t.indexName, t.keyHash), index("by_table_index").on(t.tableKey, t.indexName)]);
-const countMemberTable = convexTable(AGGREGATE_MEMBER_TABLE, {
-	kind: text().notNull(),
-	tableKey: text().notNull(),
-	indexName: text().notNull(),
-	docId: text().notNull(),
-	keyHash: text().notNull(),
-	keyParts: custom(v.array(v.any())).notNull(),
-	sumValues: custom(v.record(v.string(), v.number())).notNull(),
-	nonNullCountValues: custom(v.record(v.string(), v.number())).notNull(),
-	extremaValues: custom(v.record(v.string(), v.any())).notNull(),
-	rankNamespace: custom(v.any()),
-	rankKey: custom(v.any()),
-	rankSumValue: integer(),
-	updatedAt: integer().notNull()
-}, (t) => [index("by_kind_table_index_doc").on(t.kind, t.tableKey, t.indexName, t.docId), index("by_kind_table_index").on(t.kind, t.tableKey, t.indexName)]);
-const countExtremaTable = convexTable(AGGREGATE_EXTREMA_TABLE, {
-	tableKey: text().notNull(),
-	indexName: text().notNull(),
-	keyHash: text().notNull(),
-	fieldName: text().notNull(),
-	valueHash: text().notNull(),
-	value: custom(v.any()).notNull(),
-	sortKey: text().notNull(),
-	count: integer().notNull(),
-	updatedAt: integer().notNull()
-}, (t) => [
-	index("by_table_index").on(t.tableKey, t.indexName),
-	index("by_table_index_hash_field_value").on(t.tableKey, t.indexName, t.keyHash, t.fieldName, t.valueHash),
-	index("by_table_index_hash_field_sort").on(t.tableKey, t.indexName, t.keyHash, t.fieldName, t.sortKey)
-]);
-const countStateTable = convexTable(AGGREGATE_STATE_TABLE, {
-	kind: text().notNull(),
-	tableKey: text().notNull(),
-	indexName: text().notNull(),
-	keyDefinitionHash: text().notNull(),
-	metricDefinitionHash: text().notNull(),
-	status: text().notNull(),
-	cursor: text(),
-	processed: integer().notNull(),
-	startedAt: integer().notNull(),
-	updatedAt: integer().notNull(),
-	completedAt: integer(),
-	lastError: text()
-}, (t) => [index("by_kind_table_index").on(t.kind, t.tableKey, t.indexName), index("by_kind_status").on(t.kind, t.status)]);
-const aggregateCounterValidator = v.object({
-	count: v.number(),
-	sum: v.number()
-});
-const aggregateItemValidator = v.object({
-	k: v.any(),
-	v: v.any(),
-	s: v.number()
-});
-const rankTreeTable = convexTable(AGGREGATE_RANK_TREE_TABLE, {
-	aggregateName: text().notNull(),
-	maxNodeSize: integer().notNull(),
-	namespace: custom(v.any()),
-	root: id(AGGREGATE_RANK_NODE_TABLE).notNull()
-}, (tree) => [index("by_namespace").on(tree.namespace), index("by_aggregate_name").on(tree.aggregateName)]);
-const rankNodeTable = convexTable(AGGREGATE_RANK_NODE_TABLE, {
-	aggregate: custom(aggregateCounterValidator),
-	items: custom(v.array(aggregateItemValidator)).notNull(),
-	subtrees: custom(v.array(v.string())).notNull()
-});
-const aggregateStorageTables = {
-	[AGGREGATE_BUCKET_TABLE]: countBucketTable,
-	[AGGREGATE_MEMBER_TABLE]: countMemberTable,
-	[AGGREGATE_EXTREMA_TABLE]: countExtremaTable,
-	[AGGREGATE_RANK_TREE_TABLE]: rankTreeTable,
-	[AGGREGATE_RANK_NODE_TABLE]: rankNodeTable,
-	[AGGREGATE_STATE_TABLE]: countStateTable
-};
-const AGGREGATE_STORAGE_TABLE_NAMES = new Set([
-	AGGREGATE_BUCKET_TABLE,
-	AGGREGATE_MEMBER_TABLE,
-	AGGREGATE_EXTREMA_TABLE,
-	AGGREGATE_RANK_TREE_TABLE,
-	AGGREGATE_RANK_NODE_TABLE,
-	AGGREGATE_STATE_TABLE
-]);
-function injectAggregateStorageTables(schema) {
-	const merged = { ...schema };
-	for (const [tableName, tableDef] of Object.entries(aggregateStorageTables)) {
-		if (tableName in schema && schema[tableName] !== tableDef) throw new Error(`defineSchema cannot inject internal table '${tableName}' because the name is already in use.`);
-		merged[tableName] = tableDef;
-	}
-	return merged;
-}
-
 //#endregion
 //#region src/orm/aggregate-index/runtime.ts
 const UNDEFINED_SENTINEL = "__betterConvexUndefined";
@@ -9062,53 +8902,6 @@ function simpleStableHash(value) {
 	return `m_${(hashA >>> 0).toString(16).padStart(8, "0")}${(hashB >>> 0).toString(16).padStart(8, "0")}`;
 }
 
-//#endregion
-//#region src/orm/migrations/schema.ts
-const MIGRATION_STATE_TABLE = "migration_state";
-const MIGRATION_RUN_TABLE = "migration_run";
-const migrationStateTable = convexTable(MIGRATION_STATE_TABLE, {
-	migrationId: text().notNull(),
-	checksum: text().notNull(),
-	applied: boolean().notNull(),
-	status: text().notNull(),
-	direction: text(),
-	runId: text(),
-	cursor: text(),
-	processed: integer().notNull(),
-	startedAt: integer(),
-	updatedAt: integer().notNull(),
-	completedAt: integer(),
-	lastError: text(),
-	writeMode: text().notNull()
-}, (t) => [index("by_migration_id").on(t.migrationId), index("by_status").on(t.status)]);
-const migrationRunTable = convexTable(MIGRATION_RUN_TABLE, {
-	runId: text().notNull(),
-	direction: text().notNull(),
-	status: text().notNull(),
-	dryRun: boolean().notNull(),
-	allowDrift: boolean().notNull(),
-	migrationIds: custom(v.array(v.string())).notNull(),
-	currentIndex: integer().notNull(),
-	startedAt: integer().notNull(),
-	updatedAt: integer().notNull(),
-	completedAt: integer(),
-	cancelRequested: boolean().notNull(),
-	lastError: text()
-}, (t) => [index("by_run_id").on(t.runId), index("by_status").on(t.status)]);
-const migrationStorageTables = {
-	[MIGRATION_STATE_TABLE]: migrationStateTable,
-	[MIGRATION_RUN_TABLE]: migrationRunTable
-};
-const MIGRATION_STORAGE_TABLE_NAMES = new Set([MIGRATION_STATE_TABLE, MIGRATION_RUN_TABLE]);
-function injectMigrationStorageTables(schema) {
-	const merged = { ...schema };
-	for (const [tableName, tableDef] of Object.entries(migrationStorageTables)) {
-		if (tableName in schema && schema[tableName] !== tableDef) throw new Error(`defineSchema cannot inject internal table '${tableName}' because the name is already in use.`);
-		merged[tableName] = tableDef;
-	}
-	return merged;
-}
-
 //#endregion
 //#region src/orm/migrations/runtime.ts
 const DEFAULT_BATCH_SIZE = 128;
@@ -9767,9 +9560,9 @@ function scheduledMutationBatchFactory(schema, edgeMetadata, scheduledMutationBa
 
 //#endregion
 //#region src/orm/create-orm.ts
-const RESET_INTERNAL_TABLE_NAMES = [...AGGREGATE_STORAGE_TABLE_NAMES, ...MIGRATION_STORAGE_TABLE_NAMES];
 function getResetTableNames(schema) {
-	return [...new Set([...Object.values(schema).map((tableConfig) => tableConfig.name), ...RESET_INTERNAL_TABLE_NAMES])];
+	const pluginTables = schema[OrmSchemaPluginTables];
+	return [...new Set([...Object.values(schema).map((tableConfig) => tableConfig.name), ...pluginTables ?? []])];
 }
 function isOrmCtx(source) {
 	return !!source && typeof source === "object" && "db" in source;
@@ -10143,6 +9936,7 @@ function defineRelations(schema, relations) {
 	const strict = schemaOptions?.strict ?? true;
 	const defaults = schemaOptions?.defaults;
 	const schemaDefinition = schema[OrmSchemaDefinition];
+	const pluginTableNames = schema[OrmSchemaPluginTables];
 	const tablesConfig = buildRelations(tables, relations ? relations(createRelationsHelper(tables)) : {}, strict, defaults);
 	Object.defineProperty(tablesConfig, OrmSchemaOptions, {
 		value: {
@@ -10155,6 +9949,10 @@ function defineRelations(schema, relations) {
 		value: schemaDefinition,
 		enumerable: false
 	});
+	if (pluginTableNames) Object.defineProperty(tablesConfig, OrmSchemaPluginTables, {
+		value: pluginTableNames,
+		enumerable: false
+	});
 	return tablesConfig;
 }
 function defineRelationsPart(schema, relations) {
@@ -10163,6 +9961,7 @@ function defineRelationsPart(schema, relations) {
 	const strict = schemaOptions?.strict ?? true;
 	const defaults = schemaOptions?.defaults;
 	const schemaDefinition = schema[OrmSchemaDefinition];
+	const pluginTableNames = schema[OrmSchemaPluginTables];
 	const tablesConfig = buildRelationsParts(tables, relations ? relations(createRelationsHelper(tables)) : Object.fromEntries(Object.keys(tables).map((k) => [k, {}])), strict, defaults);
 	Object.defineProperty(tablesConfig, OrmSchemaOptions, {
 		value: {
@@ -10175,6 +9974,10 @@ function defineRelationsPart(schema, relations) {
 		value: schemaDefinition,
 		enumerable: false
 	});
+	if (pluginTableNames) Object.defineProperty(tablesConfig, OrmSchemaPluginTables, {
+		value: pluginTableNames,
+		enumerable: false
+	});
 	return tablesConfig;
 }
 function processRelations(tablesConfig, tables) {
@@ -10262,6 +10065,7 @@ const DEFAULTS_NUMERIC_FIELDS = [
 	"mutationScheduleCallCap"
 ];
 const MUTATION_EXECUTION_MODES = ["sync", "async"];
+const BUILTIN_SCHEMA_PLUGINS = [aggregatePlugin(), migrationPlugin()];
 const normalizeDefaults = (defaults) => {
 	if (!defaults) return;
 	const normalized = {};
@@ -10282,6 +10086,27 @@ const normalizeDefaults = (defaults) => {
 	}
 	return normalized;
 };
+function resolveSchemaPlugins(plugins) {
+	const resolved = [...BUILTIN_SCHEMA_PLUGINS, ...plugins ?? []];
+	const seen = /* @__PURE__ */ new Set();
+	for (const plugin of resolved) {
+		if (seen.has(plugin.key)) throw new Error(`defineSchema received duplicate plugin '${plugin.key}'. Remove duplicate plugin registrations.`);
+		seen.add(plugin.key);
+	}
+	return resolved;
+}
+function applySchemaPlugins(schema, plugins) {
+	let current = schema;
+	const pluginTableNames = [];
+	for (const plugin of plugins) {
+		current = plugin.inject(current);
+		for (const tableName of plugin.tableNames) if (!pluginTableNames.includes(tableName)) pluginTableNames.push(tableName);
+	}
+	return {
+		schema: current,
+		pluginTableNames
+	};
+}
 /**
 * Better Convex schema definition
 *
@@ -10292,7 +10117,8 @@ const normalizeDefaults = (defaults) => {
 function defineSchema(schema, options) {
 	const strict = options?.strict ?? true;
 	const defaults = normalizeDefaults(options?.defaults);
-	const schemaWithInternals = injectMigrationStorageTables(injectAggregateStorageTables(schema));
+	const { schema: schemaWithPlugins, pluginTableNames } = applySchemaPlugins(schema, resolveSchemaPlugins(options?.plugins));
+	const frozenPluginTableNames = Object.freeze([...pluginTableNames]);
 	Object.defineProperty(schema, OrmSchemaOptions, {
 		value: {
 			strict,
@@ -10300,15 +10126,23 @@ function defineSchema(schema, options) {
 		},
 		enumerable: false
 	});
-	Object.defineProperty(schemaWithInternals, OrmSchemaOptions, {
+	Object.defineProperty(schemaWithPlugins, OrmSchemaOptions, {
 		value: {
 			strict,
 			defaults
 		},
 		enumerable: false
 	});
-	const { strict: _strict, defaults: _defaults, ...convexOptions } = options ?? {};
-	const convexSchema = defineSchema$1(schemaWithInternals, convexOptions);
+	Object.defineProperty(schema, OrmSchemaPluginTables, {
+		value: frozenPluginTableNames,
+		enumerable: false
+	});
+	Object.defineProperty(schemaWithPlugins, OrmSchemaPluginTables, {
+		value: frozenPluginTableNames,
+		enumerable: false
+	});
+	const { strict: _strict, defaults: _defaults, plugins: _plugins, ...convexOptions } = options ?? {};
+	const convexSchema = defineSchema$1(schemaWithPlugins, convexOptions);
 	Object.defineProperty(convexSchema, OrmSchemaOptions, {
 		value: {
 			strict,
@@ -10316,11 +10150,15 @@ function defineSchema(schema, options) {
 		},
 		enumerable: false
 	});
+	Object.defineProperty(convexSchema, OrmSchemaPluginTables, {
+		value: frozenPluginTableNames,
+		enumerable: false
+	});
 	Object.defineProperty(schema, OrmSchemaDefinition, {
 		value: convexSchema,
 		enumerable: false
 	});
-	Object.defineProperty(schemaWithInternals, OrmSchemaDefinition, {
+	Object.defineProperty(schemaWithPlugins, OrmSchemaDefinition, {
 		value: convexSchema,
 		enumerable: false
 	});
@@ -10332,4 +10170,4 @@ function defineSchema(schema, options) {
 }
 
 //#endregion
-export { Brand, Columns, OrmNotFoundError, RlsPolicy, RlsRole, TableName, aggregateIndex, and, asc, between, bigint, boolean, buildMigrationPlan, bytes, check, contains, convexTable, createOrm, custom, date, defineMigration, defineMigrationSet, defineRelations, defineRelationsPart, defineSchema, defineTriggers, deletion, deprecated, desc, detectMigrationDrift, endsWith, eq, extractRelationsConfig, fieldRef, foreignKey, getByIdWithOrmQueryFallback, getTableColumns, getTableConfig, gt, gte, id, ilike, inArray, index, integer, isFieldReference, isNotNull, isNull, json, like, lt, lte, ne, not, notBetween, notInArray, or, pretend, pretendRequired, rankIndex, rlsPolicy, rlsRole, scheduledDeleteFactory, scheduledMutationBatchFactory, searchIndex, startsWith, text, textEnum, timestamp, unique, uniqueIndex, unsetToken, vector, vectorIndex };
+export { Brand, Columns, OrmNotFoundError, OrmSchemaPluginTables, RlsPolicy, RlsRole, TableName, aggregateIndex, and, arrayOf, asc, between, bigint, boolean, buildMigrationPlan, bytes, check, contains, convexTable, createOrm, custom, date, defineMigration, defineMigrationSet, defineRelations, defineRelationsPart, defineSchema, defineTriggers, deletion, deprecated, desc, detectMigrationDrift, endsWith, eq, extractRelationsConfig, fieldRef, foreignKey, getByIdWithOrmQueryFallback, getTableColumns, getTableConfig, gt, gte, id, ilike, inArray, index, integer, isFieldReference, isNotNull, isNull, json, like, lt, lte, ne, not, notBetween, notInArray, objectOf, or, pretend, pretendRequired, rankIndex, rlsPolicy, rlsRole, scheduledDeleteFactory, scheduledMutationBatchFactory, searchIndex, startsWith, text, textEnum, timestamp, unique, uniqueIndex, unsetToken, vector, vectorIndex };

package/dist/plugins/index.d.ts

@@ -0,0 +1,9 @@
+import { ni as OrmSchemaPlugin } from "../where-clause-compiler-BIjTkVVJ.js";
+
+//#region src/orm/migrations/schema.d.ts
+declare function migrationPlugin(): OrmSchemaPlugin;
+//#endregion
+//#region src/orm/aggregate-index/schema.d.ts
+declare function aggregatePlugin(): OrmSchemaPlugin;
+//#endregion
+export { aggregatePlugin, migrationPlugin };

package/dist/plugins/index.js

@@ -0,0 +1,3 @@
+import { c as aggregatePlugin, r as migrationPlugin } from "../schema-Bx6j2doh.js";
+
+export { aggregatePlugin, migrationPlugin };

package/dist/plugins/ratelimit/index.d.ts

@@ -0,0 +1,222 @@
+import { ni as OrmSchemaPlugin } from "../../where-clause-compiler-BIjTkVVJ.js";
+import * as convex_server0 from "convex/server";
+
+//#region src/plugins/ratelimit/duration.d.ts
+type DurationUnit = 'ms' | 's' | 'm' | 'h' | 'd';
+type DurationString = `${number} ${DurationUnit}` | `${number}${DurationUnit}`;
+type Duration = number | DurationString;
+declare function toMs(duration: Duration): number;
+//#endregion
+//#region src/plugins/ratelimit/types.d.ts
+type RatelimitReason = 'timeout' | 'cacheBlock' | 'denyList';
+type RatelimitResponse = {
+  success: boolean;
+  ok: boolean;
+  limit: number;
+  remaining: number;
+  reset: number;
+  pending: Promise<unknown>;
+  reason?: RatelimitReason;
+  deniedValue?: string;
+};
+type RemainingResponse = {
+  remaining: number;
+  reset: number;
+  limit: number;
+};
+type DynamicLimitResponse = {
+  dynamicLimit: number | null;
+};
+type RateLimitState = {
+  value: number;
+  ts: number;
+  auxValue?: number;
+  auxTs?: number;
+};
+type RateLimitSnapshot = {
+  value: number;
+  ts: number;
+  shard: number;
+  config: ResolvedAlgorithm;
+};
+type BaseAlgorithmOptions = {
+  shards?: number;
+  maxReserved?: number;
+};
+type FixedWindowAlgorithm = {
+  kind: 'fixedWindow';
+  limit: number;
+  window: number;
+  capacity: number;
+  start?: number;
+  maxReserved?: number;
+  shards: number;
+};
+type SlidingWindowAlgorithm = {
+  kind: 'slidingWindow';
+  limit: number;
+  window: number;
+  maxReserved?: number;
+  shards: number;
+};
+type TokenBucketAlgorithm = {
+  kind: 'tokenBucket';
+  refillRate: number;
+  interval: number;
+  maxTokens: number;
+  maxReserved?: number;
+  shards: number;
+};
+type ResolvedAlgorithm = FixedWindowAlgorithm | SlidingWindowAlgorithm | TokenBucketAlgorithm;
+type AlgorithmOptions = BaseAlgorithmOptions & {
+  capacity?: number;
+  start?: number;
+};
+type LimitRequest = {
+  rate?: number;
+  count?: number;
+  reserve?: boolean;
+  ip?: string;
+  userAgent?: string;
+  country?: string;
+  geo?: unknown;
+};
+type CheckRequest = Omit<LimitRequest, 'reserve'> & {
+  reserve?: boolean;
+};
+type FailureMode = 'closed' | 'open';
+type ProtectionLists = {
+  identifiers?: readonly string[];
+  ips?: readonly string[];
+  userAgents?: readonly string[];
+  countries?: readonly string[];
+};
+type RatelimitConfig = {
+  db?: ConvexRateLimitDbReader | ConvexRateLimitDbWriter;
+  limiter: ResolvedAlgorithm;
+  prefix?: string;
+  dynamicLimits?: boolean;
+  ephemeralCache?: Map<string, number> | false;
+  timeout?: number;
+  failureMode?: FailureMode;
+  enableProtection?: boolean;
+  denyListThreshold?: number;
+  denyList?: ProtectionLists;
+};
+type RateLimitRow = {
+  _id: string;
+  _creationTime?: number;
+  name: string;
+  key?: string;
+  shard: number;
+  value: number;
+  ts: number;
+  auxValue?: number;
+  auxTs?: number;
+};
+type ConvexQueryBuilder = {
+  withIndex: (name: any, cb: any) => {
+    unique: () => Promise<any>;
+    collect: () => Promise<any[]>;
+  };
+};
+type ConvexRateLimitDbReader = {
+  query: (tableName: string) => ConvexQueryBuilder;
+};
+type ConvexRateLimitDbWriter = ConvexRateLimitDbReader & {
+  insert: (...args: any[]) => Promise<any>;
+  patch: (...args: any[]) => Promise<void>;
+  delete: (...args: any[]) => Promise<void>;
+};
+type HookAPIOptions = {
+  identifier?: string | ((ctx: unknown, fromClient?: string) => string | Promise<string>);
+  sampleShards?: number;
+};
+type HookCheckValue = {
+  value: number;
+  ts: number;
+  config: ResolvedAlgorithm;
+  shard: number;
+  ok: boolean;
+  retryAt?: number;
+};
+//#endregion
+//#region src/plugins/ratelimit/core/algorithms.d.ts
+declare function fixedWindow(limit: number, window: Duration, options?: AlgorithmOptions): FixedWindowAlgorithm;
+declare function slidingWindow(limit: number, window: Duration, options?: AlgorithmOptions): SlidingWindowAlgorithm;
+declare function tokenBucket(refillRate: number, interval: Duration, maxTokens: number, options?: AlgorithmOptions): TokenBucketAlgorithm;
+declare function applyDynamicLimit(algorithm: ResolvedAlgorithm, dynamicLimit: number | null): ResolvedAlgorithm;
+//#endregion
+//#region src/plugins/ratelimit/core/calculate-rate-limit.d.ts
+type EvaluationResult = {
+  state: RateLimitState;
+  retryAfter?: number;
+  remaining: number;
+  reset: number;
+  limit: number;
+};
+declare function calculateRateLimit(state: RateLimitState | null, algorithm: ResolvedAlgorithm, now: number, count: number): EvaluationResult;
+//#endregion
+//#region src/plugins/ratelimit/ratelimit.d.ts
+declare class Ratelimit {
+  private readonly config;
+  static fixedWindow: typeof fixedWindow;
+  static slidingWindow: typeof slidingWindow;
+  static tokenBucket: typeof tokenBucket;
+  private readonly store;
+  private readonly prefix;
+  private readonly timeout;
+  private readonly dynamicLimits;
+  private readonly failureMode;
+  private readonly enableProtection;
+  private readonly denyListThreshold;
+  private readonly denyList?;
+  private readonly limiter;
+  private readonly blockCache?;
+  private readonly blockCacheSource?;
+  private readonly checkCache;
+  constructor(config: RatelimitConfig);
+  limit(identifier: string, request?: LimitRequest): Promise<RatelimitResponse>;
+  check(identifier: string, request?: CheckRequest): Promise<RatelimitResponse>;
+  blockUntilReady(identifier: string, timeoutMs: number): Promise<RatelimitResponse>;
+  resetUsedTokens(identifier: string): Promise<void>;
+  getRemaining(identifier: string): Promise<RemainingResponse>;
+  getValue(identifier: string, options?: {
+    sampleShards?: number;
+  }): Promise<RateLimitSnapshot>;
+  setDynamicLimit(options: {
+    limit: number | false;
+  }): Promise<void>;
+  getDynamicLimit(): Promise<DynamicLimitResponse>;
+  hookAPI(options?: HookAPIOptions): {
+    getRateLimit: convex_server0.RegisteredQuery<"public", {
+      identifier?: string | undefined;
+      sampleShards?: number | undefined;
+    }, Promise<RateLimitSnapshot>>;
+    getServerTime: convex_server0.RegisteredMutation<"public", {}, Promise<number>>;
+  };
+  private withDb;
+  private evaluate;
+  private evaluateCandidates;
+  private resolveAlgorithm;
+  private rawLimit;
+  private runWithTimeout;
+  private timeoutResponse;
+}
+//#endregion
+//#region src/plugins/ratelimit/schema.d.ts
+declare function ratelimitPlugin(): OrmSchemaPlugin;
+//#endregion
+//#region src/plugins/ratelimit/store/convex-store.d.ts
+declare const RATE_LIMIT_STATE_TABLE = "ratelimit_state";
+declare const RATE_LIMIT_DYNAMIC_TABLE = "ratelimit_dynamic_limit";
+declare const RATE_LIMIT_HIT_TABLE = "ratelimit_protection_hit";
+//#endregion
+//#region src/plugins/ratelimit/index.d.ts
+declare const SECOND = 1000;
+declare const MINUTE: number;
+declare const HOUR: number;
+declare const DAY: number;
+declare const WEEK: number;
+//#endregion
+export { type CheckRequest, type ConvexQueryBuilder, type ConvexRateLimitDbReader, type ConvexRateLimitDbWriter, DAY, type Duration, type DurationString, type DurationUnit, type DynamicLimitResponse, type FixedWindowAlgorithm, HOUR, type HookAPIOptions, type HookCheckValue, type LimitRequest, MINUTE, RATE_LIMIT_DYNAMIC_TABLE, RATE_LIMIT_HIT_TABLE, RATE_LIMIT_STATE_TABLE, type RateLimitRow, type RateLimitSnapshot, type RateLimitState, Ratelimit, type RatelimitConfig, type RatelimitReason, type RatelimitResponse, type RemainingResponse, type ResolvedAlgorithm, SECOND, type SlidingWindowAlgorithm, type TokenBucketAlgorithm, WEEK, applyDynamicLimit, calculateRateLimit, fixedWindow, ratelimitPlugin, slidingWindow, toMs, tokenBucket };