@voltro/plugin-progression 0.0.0-stage → 0.87.0

package/dist/passStore.js

@@ -0,0 +1,485 @@
+import { ProgressionError as e, progressionError as t } from "./errors.js";
+import { captureArguments as n, identifier as r, integer as i, list as a, object as o, progressValue as s } from "./capture.js";
+import { captureRewards as c } from "./reward.js";
+import { capturePassState as l, claimablePassTiers as u, defaultPassCatchUp as d, defineSeasonPass as f, passInitialState as p, passTier as m, resolvePassCatchUp as h } from "./pass.js";
+import { admitRewardDeliveryRecord as g } from "./rewardDeliveryRecord.js";
+import { questHash as _ } from "./questStore.js";
+import { applyPassIntent as v, capturePassIntent as y } from "./passRules.js";
+import { passDefinitionsTable as b, passLedgerTable as x, passOperationsTable as S, passRewardsTable as C, passStatesTable as w, passSubjectsTable as T } from "./passTables.entity.js";
+import { Effect as E } from "effect";
+import { and as D, eq as O, queryFor as k } from "@voltro/database";
+//#region src/passStore.ts
+var A = (e) => {
+	let n = o(e, [
+		"definitions",
+		"allowedServices",
+		"now",
+		"maxHistoryRows",
+		"maxPendingRewards",
+		"strategies"
+	]), s = o(n.strategies ?? {}, ["passCatchUp", "version"]), c = Object.freeze(a(n.definitions, 64).map((e) => f(e))), l = Object.freeze(a(n.allowedServices ?? [], 256).map(r)), u = n.now ?? Date.now, p = s.passCatchUp ?? d;
+	if (!c.length || new Set(c.map((e) => e.id)).size !== c.length || new Set(l).size !== l.length || typeof u != "function" || typeof p != "function" || p !== d && s.version === void 0) throw t("invalid_input");
+	return Object.freeze({
+		definitions: c,
+		allowedServices: l,
+		now: u,
+		maxHistoryRows: i(n.maxHistoryRows ?? 1e4, 1, 1e5),
+		maxPendingRewards: i(n.maxPendingRewards ?? 1e4, 1, 1e5),
+		strategies: Object.freeze({
+			passCatchUp: p,
+			version: r(s.version ?? "default.v1")
+		})
+	});
+}, j = (e, ...t) => e + _(t).slice(0, 56), M = (e) => i(e instanceof Date ? e.getTime() : typeof e == "string" ? Date.parse(e) : NaN, 0, 864e13), N = (n) => E.tryPromise({
+	try: n,
+	catch: (n) => n instanceof e ? n : t("unavailable")
+}), P = (f, P) => {
+	let F = A(P), I = new Map(F.definitions.map((e) => [e.id, e])), L = new Set(F.allowedServices), R = (e) => {
+		let n = I.get(e);
+		if (!n) throw t("invalid_input");
+		return n;
+	}, z = (e) => {
+		if (e.type !== "system" && !(e.type === "service" && L.has(e.service))) throw t("forbidden");
+	}, B = (e) => {
+		if (e.type !== "user" || !e.tenantId) throw t("forbidden");
+		return {
+			tenantId: r(e.tenantId),
+			ownerId: r(e.id)
+		};
+	}, V = (e, t) => j("pps_", e, t), H = (e, t) => D(O("tenantId", e), O("ownerKey", V(e, t))), U = (e, t, n) => j("ppv_", e, t, n.id, String(n.version)), W = async (e, n) => {
+		if ((await f.insertIgnoreWithOutcome(e.tableName, n, { conflictColumns: ["id"] })).outcome !== "inserted" && !(await f.query(k(e).where(O("id", n.id)).limit(1).descriptor))[0]) throw t("unavailable");
+	}, G = (e, t) => W(T, {
+		id: V(e, t),
+		tenantId: e,
+		ownerId: t,
+		erased: !1,
+		sequence: 0,
+		admission: 0
+	}), K = (e, n, r) => {
+		if (e) {
+			if (e.id !== V(n, r) || e.tenantId !== n || typeof e.erased != "boolean") throw t("invalid_record");
+			if (e.erased) throw e.ownerId === null ? t("erased") : t("invalid_record");
+			if (e.ownerId !== r) throw t("invalid_record");
+			i(e.sequence, 0, 2147483647);
+		}
+	}, q = async (e, n, r) => {
+		if (await e.updateMany(T.tableName, { admission: 0 }, { where: O("id", V(n, r)) }) !== 1) throw t("invalid_record");
+		let i = (await e.query(k(T).where(O("id", V(n, r))).limit(1).descriptor))[0];
+		if (K(i, n, r), !i) throw t("invalid_record");
+		return i;
+	}, J = async (e, n, r, i) => {
+		let a = n === C ? F.maxPendingRewards : F.maxHistoryRows, o = await e.query(k(n).where(H(r, i)).limit(a + 1).descriptor);
+		if (o.length > a) throw t("limit_exceeded");
+		if (o.some((e) => e.tenantId !== r || e.ownerKey !== V(r, i))) throw t("invalid_record");
+		return o;
+	}, Y = async (e, n, r, i) => {
+		let a = j("ppd_", n, r.id, String(r.version));
+		if (i && await e.updateMany(b.tableName, { admission: 0 }, { where: O("id", a) }) !== 1) throw t("invalid_record");
+		let o = (await e.query(k(b).where(O("id", a)).limit(1).descriptor))[0];
+		if (!o || o.tenantId !== n || o.passId !== r.id || o.version !== r.version || o.rulesVersion !== F.strategies.version || _(o.config) !== _(r)) throw t("conflict");
+	}, X = (e, n, r, i) => {
+		if (e.id !== U(n, r, i) || e.tenantId !== n || e.ownerId !== r || e.ownerKey !== V(n, r) || e.passId !== i.id || e.version !== i.version) throw t("invalid_record");
+		let a = l(e.state, i);
+		if (M(e.updatedAt) !== a.updatedAt) throw t("invalid_record");
+		return a;
+	}, Z = (e) => {
+		let n = o(e.receipt, [
+			"operationId",
+			"kind",
+			"after",
+			"claims",
+			"rewardsQueued",
+			"at"
+		]), s = o(n.after), u = R(r(s.passId)), d = l(n.after, u);
+		if (e.state !== "committed" || n.operationId !== e.id || n.kind !== "xp" && n.kind !== "premium" && n.kind !== "claim" && n.kind !== "close" || n.at !== M(e.at) || n.at !== d.updatedAt) throw t("invalid_record");
+		let f = Object.freeze(a(n.claims, 512).map((e) => {
+			let n = o(e, [
+				"tier",
+				"track",
+				"rewards"
+			]), r = i(n.tier, 1, u.tiers);
+			if (n.track !== "free" && n.track !== "premium" || _(n.rewards) !== _(u.tracks[n.track][r - 1])) throw t("invalid_record");
+			return Object.freeze({
+				tier: r,
+				track: n.track,
+				rewards: c(n.rewards, 64)
+			});
+		}));
+		if (new Set(f.map((e) => `${e.track}:${e.tier}`)).size !== f.length || n.rewardsQueued !== f.reduce((e, t) => e + t.rewards.length, 0)) throw t("invalid_record");
+		return Object.freeze({
+			operationId: r(e.id),
+			kind: n.kind,
+			after: d,
+			claims: f,
+			rewardsQueued: i(n.rewardsQueued, 0, 32768),
+			at: d.updatedAt
+		});
+	}, ee = async (e, n, r, i, a) => {
+		let o = (await e.query(k(S).where(O("id", n)).limit(1).descriptor))[0];
+		if (!o) return;
+		if (o.state === "erased") throw t("erased");
+		if (o.tenantId !== i || o.ownerKey !== V(i, a) || o.digest !== r) throw t("conflict");
+		if (o.state === "committed" && o.linkedOperationId === null) return Z(o);
+		if (o.state !== "replayed" || o.receipt !== null || typeof o.linkedOperationId != "string") throw t("invalid_record");
+		let s = (await e.query(k(S).where(O("id", o.linkedOperationId)).limit(1).descriptor))[0];
+		if (!s || s.tenantId !== i || s.ownerKey !== V(i, a) || s.digest !== r || s.originKey !== o.originKey || s.linkedOperationId !== null) throw t("invalid_record");
+		return Z(s);
+	}, Q = (a, c, l) => {
+		try {
+			let e = n(a), u = o(c, l === "xp" ? [
+				"tenantId",
+				"ownerId",
+				"passId",
+				"amount",
+				"source",
+				"originId",
+				"requestId"
+			] : l === "premium" ? [
+				"tenantId",
+				"ownerId",
+				"passId",
+				"offerId",
+				"fulfillmentId",
+				"requestId"
+			] : l === "claim" ? [
+				"passId",
+				"tier",
+				"track",
+				"requestId"
+			] : [
+				"tenantId",
+				"ownerId",
+				"passId",
+				"requestId"
+			]), { tenantId: d, ownerId: m } = l === "claim" ? B(e) : (z(e), {
+				tenantId: r(u.tenantId),
+				ownerId: r(u.ownerId)
+			}), g = R(r(u.passId)), E = r(u.requestId), D = l === "xp" ? y({
+				kind: l,
+				amount: String(s(u.amount)),
+				effectiveAmount: String(s(u.amount)),
+				source: u.source,
+				originId: u.originId
+			}, g) : l === "premium" ? y({
+				kind: l,
+				offerId: u.offerId,
+				fulfillmentId: u.fulfillmentId
+			}, g) : l === "claim" ? y({
+				kind: l,
+				tier: u.tier,
+				track: u.track
+			}, g) : { kind: l }, A = _({
+				tenantId: d,
+				ownerId: m,
+				passId: g.id,
+				version: g.version,
+				intent: D
+			}), M = j("ppo_", d, m, E), P = D.kind === "xp" ? [
+				D.kind,
+				D.source,
+				D.originId
+			] : D.kind === "premium" ? [D.kind, D.fulfillmentId] : D.kind === "claim" ? [
+				D.kind,
+				D.track,
+				String(D.tier)
+			] : [D.kind], I = j("ppk_", d, m, g.id, String(g.version), ...P);
+			return N(async () => {
+				await G(d, m);
+				let e = async (e) => {
+					await q(e, d, m);
+					let n = await ee(e, M, A, d, m);
+					if (n) return n;
+					let r = await J(e, S, d, m), i = r.find((e) => e.originKey === I && e.state === "committed");
+					if (!i) return;
+					if (i.digest !== A || i.linkedOperationId !== null) throw t("conflict");
+					let a = Z(i);
+					if (r.length >= F.maxHistoryRows) throw t("limit_exceeded");
+					return await e.insert(S.tableName, {
+						id: M,
+						tenantId: d,
+						ownerKey: V(d, m),
+						originKey: I,
+						state: "replayed",
+						linkedOperationId: a.operationId,
+						digest: A,
+						receipt: null,
+						at: new Date(a.at)
+					}), a;
+				}, n = await f.transactional(e);
+				if (n) return n;
+				let r = i(F.now(), 0, 864e13), a = D.kind === "xp" ? y({
+					...D,
+					effectiveAmount: h({
+						pass: g,
+						amount: D.amount,
+						at: r
+					}, F.strategies.passCatchUp)
+				}, g) : D;
+				return await W(b, {
+					id: j("ppd_", d, g.id, String(g.version)),
+					tenantId: d,
+					passId: g.id,
+					version: g.version,
+					config: g,
+					rulesVersion: F.strategies.version,
+					admission: 0
+				}), f.transactional(async (n) => {
+					let o = await e(n);
+					if (o) return o;
+					let s = await q(n, d, m);
+					await Y(n, d, g, !0);
+					let c = await J(n, x, d, m), u = await J(n, S, d, m), f = await J(n, C, d, m);
+					if (c.length >= F.maxHistoryRows || u.length >= F.maxHistoryRows) throw t("limit_exceeded");
+					let h = U(d, m, g), y = (await n.query(k(w).where(O("id", h)).limit(1).descriptor))[0], b = y ? X(y, d, m, g) : p(g), E = c.filter((e) => e.passId === g.id).sort((e, t) => Number(e.sequence) - Number(t.sequence)).at(-1);
+					if (E && (!y || _(E.after) !== _(b)) || !E && y) throw t("invalid_record");
+					let D = v(g, b, a, r), N = D.claims.reduce((e, t) => e + t.rewards.length, 0);
+					if (f.length + N > F.maxPendingRewards) throw t("limit_exceeded");
+					let P = i(s.sequence, 0, 2147483646) + 1, L = Object.freeze({
+						operationId: M,
+						kind: l,
+						after: D.after,
+						claims: D.claims,
+						rewardsQueued: N,
+						at: r
+					});
+					y ? await n.update(w.tableName, h, {
+						state: D.after,
+						updatedAt: new Date(r)
+					}) : await n.insert(w.tableName, {
+						id: h,
+						tenantId: d,
+						ownerId: m,
+						ownerKey: V(d, m),
+						passId: g.id,
+						version: g.version,
+						state: D.after,
+						updatedAt: new Date(r)
+					}), await n.insert(x.tableName, {
+						id: j("ppl_", M),
+						tenantId: d,
+						ownerId: m,
+						ownerKey: V(d, m),
+						passId: g.id,
+						version: g.version,
+						sequence: P,
+						operationId: M,
+						intent: a,
+						before: b,
+						after: D.after,
+						at: new Date(r)
+					}), await n.insert(S.tableName, {
+						id: M,
+						tenantId: d,
+						ownerKey: V(d, m),
+						originKey: I,
+						state: "committed",
+						linkedOperationId: null,
+						digest: A,
+						receipt: L,
+						at: new Date(r)
+					});
+					for (let e of D.claims) for (let [t, i] of e.rewards.entries()) await n.insert(C.tableName, {
+						id: j("ppr_", d, m, g.id, String(g.version), e.track, String(e.tier), String(t)),
+						tenantId: d,
+						ownerId: m,
+						ownerKey: V(d, m),
+						passId: g.id,
+						version: g.version,
+						tier: e.tier,
+						track: e.track,
+						operationId: M,
+						reward: i,
+						state: "pending",
+						createdAt: new Date(r),
+						deliveredAt: null,
+						deliveryIntent: null,
+						deliveryDigest: null,
+						deliveryReceipt: null
+					});
+					return await n.update(T.tableName, V(d, m), { sequence: P }), L;
+				});
+			});
+		} catch (n) {
+			return E.fail(n instanceof e ? n : t("invalid_input"));
+		}
+	}, te = (r) => {
+		try {
+			let { tenantId: e, ownerId: a } = B(n(r));
+			return N(async () => {
+				let n = i(F.now(), 0, 864e13);
+				return f.transactional(async (r) => {
+					let i = (await r.query(k(T).where(O("id", V(e, a))).forUpdate().limit(1).descriptor))[0];
+					K(i, e, a);
+					let o = await J(r, w, e, a), s = await J(r, x, e, a);
+					return Object.freeze(F.definitions.map((r) => {
+						let i = o.find((e) => e.passId === r.id), c = i ? X(i, e, a, r) : p(r), l = s.filter((e) => e.passId === r.id).sort((e, t) => Number(e.sequence) - Number(t.sequence)).at(-1);
+						if (l && (!i || _(l.after) !== _(c)) || !l && i || i && c.updatedAt > n) throw t("invalid_record");
+						let d = n >= r.from && n < r.until && !c.closed;
+						return Object.freeze({
+							...c,
+							tier: m(r, c.xp),
+							from: r.from,
+							until: r.until,
+							observedAt: n,
+							active: d,
+							premiumOffer: r.premiumOffer,
+							claimable: d ? u(r, c) : Object.freeze([])
+						});
+					}));
+				});
+			});
+		} catch (n) {
+			return E.fail(n instanceof e ? n : t("invalid_input"));
+		}
+	}, $ = (n, i) => {
+		try {
+			let e = o(n, [
+				"tenantId",
+				"subjectId",
+				"kind"
+			]), a = r(e.tenantId), s = r(e.subjectId);
+			if (e.kind !== "user" && e.kind !== "guest") throw t("invalid_input");
+			return N(async () => (await G(a, s), f.transactional(async (e) => {
+				if (await e.updateMany(T.tableName, { admission: 0 }, { where: O("id", V(a, s)) }) !== 1) throw t("invalid_record");
+				let n = (await e.query(k(T).where(O("id", V(a, s))).limit(1).descriptor))[0];
+				if (!n || n.tenantId !== a || typeof n.erased != "boolean" || n.erased && n.ownerId !== null || !n.erased && n.ownerId !== s) throw t("invalid_record");
+				let r = await J(e, w, a, s), o = await J(e, x, a, s), c = await J(e, S, a, s), l = await J(e, C, a, s);
+				if (!i) return {
+					passes: r.map((e) => e.state),
+					history: o.map((e) => ({
+						intent: e.intent,
+						before: e.before,
+						after: e.after
+					})),
+					requests: c.map((e) => e.receipt),
+					rewards: l.map((e) => ({
+						reward: e.reward,
+						state: e.state,
+						deliveryIntent: e.deliveryIntent,
+						deliveryReceipt: e.deliveryReceipt
+					}))
+				};
+				await e.deleteMany(w.tableName, { where: H(a, s) }), await e.updateMany(x.tableName, {
+					ownerId: null,
+					ownerKey: null,
+					intent: null,
+					before: null,
+					after: null
+				}, { where: H(a, s) }), await e.updateMany(S.tableName, {
+					ownerKey: null,
+					originKey: null,
+					state: "erased",
+					linkedOperationId: null,
+					digest: null,
+					receipt: null
+				}, { where: H(a, s) }), await e.updateMany(C.tableName, {
+					ownerId: null,
+					ownerKey: null,
+					reward: null,
+					state: "erased",
+					deliveredAt: null,
+					deliveryIntent: null,
+					deliveryDigest: null,
+					deliveryReceipt: null
+				}, { where: H(a, s) }), await e.update(T.tableName, V(a, s), {
+					ownerId: null,
+					erased: !0
+				});
+			})));
+		} catch (n) {
+			return E.fail(n instanceof e ? n : t("invalid_input"));
+		}
+	}, ne = (i, a, o, s) => {
+		try {
+			z(n(i));
+			let e = r(a), c = r(o);
+			return N(async () => (await G(e, c), f.transactional(async (n) => {
+				let i = await q(n, e, c), a = await J(n, x, e, c), o = await J(n, S, e, c), l = await J(n, C, e, c), u = /* @__PURE__ */ new Map(), f = /* @__PURE__ */ new Set(), m = [...a].sort((e, t) => Number(e.sequence) - Number(t.sequence)), b = 0;
+				if (m.length !== i.sequence) throw t("invalid_record");
+				for (let [i, a] of m.entries()) {
+					let s = R(r(a.passId)), m = u.get(s.id) ?? p(s), x = y(a.intent, s), S = M(a.at), C = o.find((e) => e.id === a.operationId);
+					if (await Y(n, e, s, !1), a.sequence !== i + 1 || a.id !== j("ppl_", r(a.operationId)) || a.ownerId !== c || a.version !== s.version || _(a.before) !== _(m) || !C || C.linkedOperationId !== null || x.kind === "xp" && F.strategies.passCatchUp === d && h({
+						pass: s,
+						amount: x.amount,
+						at: S
+					}) !== x.effectiveAmount) throw t("invalid_record");
+					let w = x.kind === "xp" ? {
+						...x,
+						effectiveAmount: x.amount
+					} : x, T = _({
+						tenantId: e,
+						ownerId: c,
+						passId: s.id,
+						version: s.version,
+						intent: w
+					}), E = x.kind === "xp" ? [
+						x.kind,
+						x.source,
+						x.originId
+					] : x.kind === "premium" ? [x.kind, x.fulfillmentId] : x.kind === "claim" ? [
+						x.kind,
+						x.track,
+						String(x.tier)
+					] : [x.kind], D = j("ppk_", e, c, s.id, String(s.version), ...E);
+					if (C.digest !== T || C.originKey !== D || f.has(D)) throw t("invalid_record");
+					let O = v(s, m, x, S), k = Z(C);
+					if (k.kind !== x.kind || _(O.after) !== _(a.after) || _(O.after) !== _(k.after) || _(O.claims) !== _(k.claims)) throw t("invalid_record");
+					let A = l.filter((e) => e.operationId === a.operationId);
+					if (A.length !== k.rewardsQueued) throw t("invalid_record");
+					for (let n of O.claims) for (let [r, i] of n.rewards.entries()) {
+						let a = A.find((t) => t.id === j("ppr_", e, c, s.id, String(s.version), n.track, String(n.tier), String(r)));
+						if (!a || a.ownerId !== c || a.passId !== s.id || a.version !== s.version || a.track !== n.track || a.tier !== n.tier || _(a.reward) !== _(i) || M(a.createdAt) !== S) throw t("invalid_record");
+						g(a, "pass", _), b++;
+					}
+					f.add(D), u.set(s.id, O.after);
+				}
+				if (b !== l.length) throw t("invalid_record");
+				for (let e of o) if (e.state === "replayed") {
+					let n = o.find((t) => t.id === e.linkedOperationId);
+					if (!n || n.state !== "committed" || n.linkedOperationId !== null || n.digest !== e.digest || n.originKey !== e.originKey || e.receipt !== null || M(e.at) !== M(n.at)) throw t("invalid_record");
+				} else if (e.state !== "committed" || !m.some((t) => t.operationId === e.id)) throw t("invalid_record");
+				let T = await J(n, w, e, c), E = /* @__PURE__ */ new Map();
+				for (let n of T) {
+					let i = R(r(n.passId));
+					if (E.has(i.id)) throw t("invalid_record");
+					E.set(i.id, X(n, e, c, i));
+				}
+				let D = E.size === u.size && [...u].every(([e, t]) => _(t) === _(E.get(e) ?? null));
+				if (s && !D) {
+					await n.deleteMany(w.tableName, { where: H(e, c) });
+					for (let [t, r] of u) await n.insert(w.tableName, {
+						id: U(e, c, R(t)),
+						tenantId: e,
+						ownerId: c,
+						ownerKey: V(e, c),
+						passId: t,
+						version: r.version,
+						state: r,
+						updatedAt: new Date(r.updatedAt)
+					});
+				}
+				return Object.freeze({
+					operations: m.length,
+					passes: u.size,
+					rewardRows: b,
+					matches: s ? !0 : D
+				});
+			})));
+		} catch (n) {
+			return E.fail(n instanceof e ? n : t("invalid_input"));
+		}
+	};
+	return Object.freeze({
+		applyXp: (e, t) => Q(e, t, "xp"),
+		grantPremium: (e, t) => Q(e, t, "premium"),
+		claim: (e, t) => Q(e, t, "claim"),
+		close: (e, t) => Q(e, t, "close"),
+		mine: te,
+		exportSubject: (e) => $(e, !1),
+		eraseSubject: (e) => E.asVoid($(e, !0)),
+		auditPasses: (e, t, n) => ne(e, t, n, !1),
+		rebuildPasses: (e, t, n) => ne(e, t, n, !0)
+	});
+};
+//#endregion
+export { P as dataStoreSeasonPasses, A as resolvePassOptions };

package/dist/passTables.entity.js

@@ -0,0 +1,96 @@
+import { boolean as e, id as t, integer as n, json as r, table as i, text as a, timestamp as o } from "@voltro/database";
+//#region src/passTables.entity.ts
+var s = () => a().maxLength(120).externalId().sensitive("pii"), c = () => a().maxLength(120).externalId().sensitive("pii"), l = () => a().maxLength(64).nullable().serverOnly(), u = i("_voltro_prog_pass_definitions", {
+	id: t({ prefix: "ppd" }),
+	tenantId: s(),
+	passId: a().maxLength(120).safe(),
+	version: n().safe(),
+	config: r().serverOnly(),
+	rulesVersion: a().maxLength(120).safe(),
+	admission: n().serverOnly()
+}).index([
+	"tenantId",
+	"passId",
+	"version"
+]), d = i("_voltro_prog_pass_subjects", {
+	id: t({ prefix: "pps" }),
+	tenantId: s(),
+	ownerId: c().nullable(),
+	erased: e().serverOnly(),
+	sequence: n().serverOnly(),
+	admission: n().serverOnly()
+}).index(["tenantId", "ownerId"]), f = i("_voltro_prog_pass", {
+	id: t({ prefix: "ppv" }),
+	tenantId: s(),
+	ownerId: c(),
+	ownerKey: l(),
+	passId: a().maxLength(120).safe(),
+	version: n().safe(),
+	state: r().serverOnly(),
+	updatedAt: o().safe()
+}).index(["tenantId", "ownerKey"]), p = i("_voltro_prog_pass_ledger", {
+	id: t({ prefix: "ppl" }),
+	tenantId: s(),
+	ownerId: c().nullable(),
+	ownerKey: l(),
+	passId: a().maxLength(120).safe(),
+	version: n().safe(),
+	sequence: n().serverOnly(),
+	operationId: a().maxLength(64).safe(),
+	intent: r().nullable().serverOnly(),
+	before: r().nullable().serverOnly(),
+	after: r().nullable().serverOnly(),
+	at: o().safe()
+}).index(["tenantId", "ownerKey"]), m = i("_voltro_prog_pass_operations", {
+	id: t({ prefix: "ppo" }),
+	tenantId: s(),
+	ownerKey: l(),
+	originKey: a().maxLength(64).nullable().serverOnly(),
+	state: a().maxLength(16).oneOf([
+		"committed",
+		"replayed",
+		"erased"
+	]).serverOnly(),
+	linkedOperationId: a().maxLength(64).nullable().serverOnly(),
+	digest: a().maxLength(64).nullable().serverOnly(),
+	receipt: r().nullable().serverOnly(),
+	at: o().safe()
+}).index([
+	"tenantId",
+	"ownerKey",
+	"originKey"
+]), h = i("_voltro_prog_pass_rewards", {
+	id: t({ prefix: "ppr" }),
+	tenantId: s(),
+	ownerId: c().nullable(),
+	ownerKey: l(),
+	passId: a().maxLength(120).safe(),
+	version: n().safe(),
+	tier: n().safe(),
+	track: a().maxLength(16).oneOf(["free", "premium"]).safe(),
+	operationId: a().maxLength(64).safe(),
+	reward: r().nullable().serverOnly(),
+	state: a().maxLength(16).oneOf([
+		"pending",
+		"delivered",
+		"erased"
+	]).serverOnly(),
+	createdAt: o().safe(),
+	deliveredAt: o().nullable().safe(),
+	deliveryIntent: r().nullable().serverOnly(),
+	deliveryDigest: a().maxLength(64).nullable().serverOnly(),
+	deliveryReceipt: r().nullable().serverOnly()
+}).index([
+	"tenantId",
+	"ownerKey",
+	"state"
+]), g = [
+	u,
+	d,
+	f,
+	p,
+	m,
+	h
+];
+//#endregion
+export { u as passDefinitionsTable, p as passLedgerTable, m as passOperationsTable, h as passRewardsTable, f as passStatesTable, d as passSubjectsTable, g as passTables };