@voltro/plugin-economy 0.0.0-stage → 0.87.0

package/dist/containers.js

@@ -0,0 +1,215 @@
+import { economyError as e } from "./errors.js";
+import { captureBoundMethods as t, dataList as n, dataObject as r, identifier as i } from "./capture.js";
+import { positiveAmount as a } from "./amount.js";
+import { captureCurrencies as o } from "./currency.js";
+import { definePrice as s } from "./price.js";
+import { shopInteger as c } from "./shop.js";
+import { Context as l } from "effect";
+//#region src/containers.ts
+var u = (t, l, u = !1) => {
+	let d = r(t, [
+		"id",
+		"version",
+		"group",
+		"price",
+		"drops",
+		"pity",
+		"countries"
+	]), f = o(l), p = Object.freeze(n(d.drops, 256).map((t) => {
+		let o = r(t, [
+			"id",
+			"rarity",
+			"weight",
+			"items",
+			"currencies"
+		]), s = Object.freeze(n(o.items ?? [], 16).map((e) => {
+			let t = r(e, ["itemId", "qty"]);
+			return Object.freeze({
+				itemId: i(t.itemId),
+				qty: c(t.qty, 1, 1e6)
+			});
+		})), l = Object.freeze(n(o.currencies ?? [], 16).map((t) => {
+			let n = r(t, ["currency", "amount"]), o = i(n.currency), s = f.find((e) => e.id === o), c = a(n.amount);
+			if (!s || c > BigInt(s.cap)) throw e("invalid_currency");
+			return Object.freeze({
+				currency: o,
+				amount: c.toString()
+			});
+		}));
+		if (!s.length && !l.length || new Set(s.map((e) => e.itemId)).size !== s.length || new Set(l.map((e) => e.currency)).size !== l.length) throw e("invalid_input");
+		return Object.freeze({
+			id: i(o.id),
+			rarity: i(o.rarity),
+			weight: a(o.weight).toString(),
+			items: s,
+			currencies: l
+		});
+	}));
+	if (!p.length || new Set(p.map((e) => e.id)).size !== p.length) throw e("invalid_input");
+	let m = null;
+	if (d.pity != null) {
+		let t = r(d.pity, [
+			"guaranteed",
+			"after",
+			"softFrom",
+			"softRampBps"
+		]), n = i(t.guaranteed), a = c(t.after, 1, 1e6), o = t.softFrom == null ? null : c(t.softFrom, 1, a), s = c(t.softRampBps ?? 0, 0, 1e4);
+		if (!p.some((e) => e.rarity === n) || o === null && s !== 0 || o !== null && s === 0) throw e("invalid_input");
+		m = Object.freeze({
+			guaranteed: n,
+			after: a,
+			softFrom: o,
+			softRampBps: s
+		});
+	}
+	let h = i(d.id), g = Object.freeze(n(d.countries ?? [], 256).map((t) => {
+		if (typeof t != "string" || !/^[A-Z]{2}$/.test(t)) throw e("invalid_input");
+		return t;
+	}).sort());
+	if (new Set(g).size !== g.length) throw e("invalid_input");
+	return Object.freeze({
+		id: h,
+		version: i(d.version ?? "1"),
+		group: i(d.group ?? h),
+		price: s(d.price, f, u),
+		drops: p,
+		pity: m,
+		countries: g
+	});
+}, d = (t, n = !0) => {
+	if (typeof t != "string" || !/^(0|[1-9][0-9]{0,255})$/.test(t) || !n && t === "0") throw e("invalid_input");
+	return BigInt(t);
+}, f = (t) => {
+	let n = r(t, [
+		"container",
+		"misses",
+		"currencies",
+		"realMoney"
+	]), i = o(n.currencies), a = n.realMoney ?? !1;
+	if (typeof a != "boolean") throw e("invalid_input");
+	let s = u(n.container, i, a), l = c(n.misses, 0, s.pity ? s.pity.after - 1 : 0);
+	return Object.freeze({
+		container: s,
+		misses: l,
+		currencies: i,
+		realMoney: a
+	});
+}, p = ({ container: e, misses: t }) => {
+	let n = e.pity, r = e.drops.map((e) => BigInt(e.weight)), i = r.reduce((e, t) => e + t, 0n);
+	if (!n) return Object.freeze(e.drops.map((e, t) => Object.freeze({
+		dropId: e.id,
+		weight: r[t].toString()
+	})));
+	let a = e.drops.reduce((e, t, i) => e + (t.rarity === n.guaranteed ? r[i] : 0n), 0n), o = i - a;
+	if (t + 1 >= n.after || o === 0n) return Object.freeze(e.drops.map((e, t) => Object.freeze({
+		dropId: e.id,
+		weight: e.rarity === n.guaranteed ? r[t].toString() : "0"
+	})));
+	if (n.softFrom === null || t + 1 < n.softFrom) return Object.freeze(e.drops.map((e, t) => Object.freeze({
+		dropId: e.id,
+		weight: r[t].toString()
+	})));
+	let s = a * 10000n + BigInt(t + 2 - n.softFrom) * BigInt(n.softRampBps) * i, c = i * 10000n, l = s > c ? c : s;
+	return Object.freeze(e.drops.map((e, t) => Object.freeze({
+		dropId: e.id,
+		weight: (e.rarity === n.guaranteed ? r[t] * l * o : r[t] * (c - l) * a).toString()
+	})));
+}, m = (t, a = p) => {
+	if (typeof a != "function") throw e("invalid_input");
+	let o = f(t), s = n(a(o), 256), c = /* @__PURE__ */ new Set(), l = Object.freeze(s.map((t) => {
+		let n = r(t, ["dropId", "weight"]), a = i(n.dropId), s = d(n.weight);
+		if (c.has(a) || !o.container.drops.some((e) => e.id === a)) throw e("invalid_input");
+		return c.add(a), Object.freeze({
+			dropId: a,
+			weight: s.toString()
+		});
+	}));
+	if (l.length !== o.container.drops.length) throw e("invalid_input");
+	let u = l.reduce((e, t) => e + d(t.weight), 0n);
+	if (u === 0n || u.toString().length > 256) throw e("invalid_input");
+	let m = o.container.pity !== null && o.misses + 1 >= o.container.pity.after;
+	if (m && l.some((e) => d(e.weight) > 0n && o.container.drops.find((t) => t.id === e.dropId).rarity !== o.container.pity.guaranteed)) throw e("invalid_input");
+	return Object.freeze({
+		entries: l,
+		total: u.toString(),
+		guaranteed: m
+	});
+}, h = (e, t = p) => {
+	let n = m(e, t);
+	return Object.freeze({
+		guaranteed: n.guaranteed,
+		probabilities: Object.freeze(n.entries.map((e) => Object.freeze({
+			dropId: e.dropId,
+			numerator: e.weight,
+			denominator: n.total
+		})))
+	});
+}, g = ({ distribution: t, draw: n }) => {
+	let r = d(n);
+	if (r >= d(t.total, !1)) throw e("invalid_input");
+	for (let e of t.entries) {
+		let t = d(e.weight);
+		if (r < t) return e.dropId;
+		r -= t;
+	}
+	throw e("invalid_input");
+}, _ = (t, n, r = p, a = g) => {
+	if (typeof a != "function") throw e("invalid_input");
+	let o = f(t), s = m(o, r), c = d(n);
+	if (c >= d(s.total, !1)) throw e("invalid_input");
+	let l = i(a(Object.freeze({
+		distribution: s,
+		draw: c.toString()
+	}))), u = s.entries.find((e) => e.dropId === l);
+	if (!u || d(u.weight) === 0n) throw e("invalid_input");
+	let h = o.container.drops.find((e) => e.id === l), _ = o.container.pity !== null && h.rarity === o.container.pity.guaranteed;
+	return Object.freeze({
+		drop: h,
+		misses: o.container.pity === null || _ ? 0 : o.misses + 1,
+		distribution: s
+	});
+}, v = class extends l.Service()("@voltro/ContainerRandomPort") {}, y = (t) => {
+	let n = r(t, [
+		"containerId",
+		"containerVersion",
+		"containerDigest",
+		"disclosureDigest",
+		"requestId",
+		"currency"
+	]);
+	if (typeof n.containerDigest != "string" || !/^[a-f0-9]{64}$/.test(n.containerDigest) || typeof n.disclosureDigest != "string" || !/^[a-f0-9]{64}$/.test(n.disclosureDigest)) throw e("invalid_input");
+	return Object.freeze({
+		containerId: i(n.containerId),
+		containerVersion: i(n.containerVersion),
+		containerDigest: n.containerDigest,
+		disclosureDigest: n.disclosureDigest,
+		requestId: i(n.requestId),
+		currency: n.currency === void 0 ? null : i(n.currency)
+	});
+}, b = (e) => !e.isMinor && e.eligible && (e.container.countries.length === 0 || e.container.countries.includes(e.country)), x = (t, n, i = !1, a = b) => {
+	let o = r(t, [
+		"container",
+		"at",
+		"isMinor",
+		"country",
+		"eligible"
+	]);
+	if (typeof a != "function" || typeof o.isMinor != "boolean" || typeof o.eligible != "boolean" || typeof o.country != "string" || !/^[A-Z]{2}$/.test(o.country)) throw e("invalid_input");
+	let s = Object.freeze({
+		container: u(o.container, n, i),
+		at: c(o.at, 0, 864e13),
+		isMinor: o.isMinor,
+		country: o.country,
+		eligible: o.eligible
+	}), l = a(s);
+	if (typeof l != "boolean") throw e("invalid_input");
+	return l && b(s);
+}, S = class extends l.Service()("@voltro/ContainersPort") {}, C = (e) => t(e, [
+	"list",
+	"open",
+	"receipt",
+	"exportSubject",
+	"eraseSubject"
+]);
+//#endregion
+export { v as ContainerRandomPort, S as ContainersPort, y as captureContainerIntent, C as captureContainersService, f as containerProbabilityContext, b as defaultContainerEligibility, p as defaultContainerProbability, g as defaultContainerRoll, u as defineContainer, h as discloseContainer, m as resolveContainerDistribution, x as resolveContainerEligibility, _ as resolveContainerRoll };

package/dist/containers.server.js

@@ -0,0 +1,40 @@
+import { EconomyError as e, economyError as t } from "./errors.js";
+import { ContainerRandomPort as n, containerProbabilityContext as r, defaultContainerProbability as i, defaultContainerRoll as a, resolveContainerDistribution as o, resolveContainerRoll as s } from "./containers.js";
+import { Effect as c, Layer as l } from "effect";
+import { randomBytes as u } from "node:crypto";
+//#region src/containers.server.ts
+var d = Object.freeze({ draw: (n) => {
+	let r;
+	try {
+		if (typeof n != "string" || !/^[1-9][0-9]{0,255}$/.test(n)) throw t("invalid_input");
+		r = BigInt(n);
+	} catch {
+		return c.fail(t("invalid_input"));
+	}
+	return c.try({
+		try: () => {
+			if (r === 1n) return "0";
+			let e = (r - 1n).toString(2).length, n = Math.ceil(e / 8), i = 255 >>> n * 8 - e;
+			for (let e = 0; e < 128; e++) {
+				let e = u(n);
+				e[0] &= i;
+				let t = BigInt("0x" + e.toString("hex"));
+				if (t < r) return t.toString();
+			}
+			throw t("conflict");
+		},
+		catch: (n) => n instanceof e ? n : t("unavailable")
+	});
+} }), f = l.succeed(n, d), p = (e, l = i, u = a) => {
+	let d = r(e), f = o(d, l), p = () => f.entries;
+	if (typeof u != "function") throw t("invalid_input");
+	return c.gen(function* () {
+		let e = yield* (yield* n).draw(f.total);
+		return yield* c.try({
+			try: () => s(d, e, p, u),
+			catch: () => t("invalid_input")
+		});
+	});
+};
+//#endregion
+export { d as cryptoContainerRandom, f as cryptoContainerRandomLayer, p as sampleContainer };

package/dist/containersPort.fixture.js

@@ -0,0 +1,75 @@
+import { ContainersPort as e } from "./containers.js";
+import { EconomyPort as t } from "./port.js";
+import { economyPlugin as n } from "./plugin.js";
+import { containerOpenIntent as r, containerStoreFixture as i } from "./containerStore.testFixtures.js";
+import { Effect as a, Layer as o } from "effect";
+import { InMemoryDataStore as s } from "@voltro/runtime";
+//#region src/containersPort.fixture.ts
+var c = {
+	app: {
+		name: "containers-fixture",
+		type: "api",
+		voltroVersion: "0.83.1"
+	},
+	config: {},
+	env: {},
+	logger: {
+		info() {},
+		warn() {},
+		error() {},
+		debug() {}
+	}
+}, l = a.gen(function* () {
+	let e = new s(), t = yield* a.promise(() => i(e, "fixture")), r = t.options, o = n({
+		currencies: r.currencies,
+		now: r.now,
+		containers: {
+			containers: r.containers,
+			inventory: r.inventory,
+			accessSource: r.accessSource,
+			version: r.version,
+			probability: r.probability,
+			roll: r.roll,
+			random: r.random,
+			eligibility: r.eligibility,
+			priceResolver: r.priceResolver,
+			systemAccount: r.systemAccount,
+			maxHistoryRows: r.maxHistoryRows,
+			now: r.now
+		}
+	});
+	return yield* a.promise(async () => {
+		await o.bindDataStore?.(e);
+	}), Object.freeze({
+		store: e,
+		plugin: o,
+		base: t,
+		close: a.suspend(() => o.onDeactivate?.(c))
+	});
+}), u = o.effectContext(a.acquireRelease(l, (e) => e.close).pipe(a.flatMap((e) => o.build(e.plugin.services)))), d = Object.freeze({
+	kind: "port",
+	tag: e,
+	fakeLayer: u,
+	probe: {
+		run: () => a.scoped(a.gen(function* () {
+			let n = yield* e, i = yield* t, a = {
+				type: "user",
+				id: "a",
+				tenantId: "fixture",
+				kind: "guest"
+			}, o = (yield* n.list(a))[0], s = r(o), c = yield* n.open(a, s), l = yield* n.open(a, s), u = yield* i.mine(a);
+			return {
+				same: c.operationId === l.operationId,
+				misses: c.misses,
+				balance: u[0]?.balance
+			};
+		}).pipe(a.provide(u))),
+		expected: {
+			same: !0,
+			misses: 1,
+			balance: "95"
+		}
+	}
+});
+//#endregion
+export { u as containersFakeLayer, l as containersPortFixture, d as containersPortSystemFixture };

package/dist/currency.js

@@ -0,0 +1,33 @@
+import { economyError as e } from "./errors.js";
+import { dataList as t, dataObject as n, identifier as r } from "./capture.js";
+import { economyAmountString as i, positiveAmount as a } from "./amount.js";
+//#region src/currency.ts
+var o = (t) => {
+	let o = n(t, [
+		"id",
+		"kind",
+		"cap",
+		"premium",
+		"display"
+	], "invalid_currency"), s = r(o.id, "invalid_currency");
+	if (o.kind !== "soft" && o.kind !== "hard" || o.premium !== void 0 && typeof o.premium != "boolean") throw e("invalid_currency");
+	let c = null;
+	if (o.display !== void 0 && o.display !== null) {
+		let e = n(o.display, ["nameKey"], "invalid_currency");
+		c = Object.freeze({ nameKey: r(e.nameKey, "invalid_currency") });
+	}
+	let l = o.cap === void 0 ? "9223372036854775807" : i(a(o.cap));
+	return Object.freeze({
+		id: s,
+		kind: o.kind,
+		cap: l,
+		premium: o.premium ?? !1,
+		display: c
+	});
+}, s = (n) => {
+	let r = t(n, 128, "invalid_currency").map((e) => o(e));
+	if (new Set(r.map((e) => e.id)).size !== r.length) throw e("invalid_currency");
+	return Object.freeze(r);
+};
+//#endregion
+export { s as captureCurrencies, o as defineCurrency };

package/dist/declarationFixtures.js

@@ -0,0 +1,62 @@
+import { defaultPriceResolver as e, priceResolverContext as t } from "./price.js";
+import { defineShopOffer as n } from "./shop.js";
+import { planLedgerTransfer as r } from "./ledger.js";
+//#region src/declarationFixtures.ts
+var i = () => Object.freeze({
+	resolver: e,
+	context: t({
+		kind: "virtual",
+		options: [{
+			currency: "test.gold",
+			amount: "11"
+		}]
+	}, [{
+		id: "test.gold",
+		kind: "soft",
+		cap: "1000"
+	}], !1, [{
+		currency: "test.gold",
+		discountBps: 5e3,
+		minimum: "2"
+	}])
+}), a = () => r({
+	tenantId: "test.tenant",
+	requestId: "test.reward.1",
+	currency: "test.gold",
+	amount: "11",
+	from: {
+		kind: "system",
+		id: "match-rewards"
+	},
+	to: {
+		kind: "wallet",
+		ownerKind: "player",
+		ownerId: "test.player"
+	},
+	reason: "match.reward",
+	ref: {
+		kind: "match",
+		id: "test.match"
+	}
+}), o = () => n({
+	id: "test.potion",
+	version: "1",
+	titleKey: "test.potion.offer",
+	price: {
+		kind: "virtual",
+		options: [{
+			currency: "test.gold",
+			amount: "7"
+		}]
+	},
+	items: [{
+		itemId: "test.potion",
+		qty: 2
+	}],
+	oneTime: !0
+}, [{
+	id: "test.gold",
+	kind: "soft"
+}]);
+//#endregion
+export { a as ledgerTransferFixture, i as priceResolverFixture, o as shopOfferFixture };

package/dist/economy-app/events/economy.refundReversed.event.ts

@@ -0,0 +1 @@
+export { economyRefundReversed as default } from '@voltro/plugin-economy/events'

package/dist/economy-app/events/economy.refunded.event.ts

@@ -0,0 +1 @@
+export { economyRefunded as default } from '@voltro/plugin-economy/events'

package/dist/economyPort.fixture.js

@@ -0,0 +1,125 @@
+import { EconomyError as e, economyError as t } from "./errors.js";
+import { dataList as n, dataObject as r, identifier as i } from "./capture.js";
+import { captureCurrencies as a } from "./currency.js";
+import { applyWalletPosting as o, captureAccount as s, economyAccountKey as c, planLedgerTransfer as l } from "./ledger.js";
+import { EconomyPort as u } from "./port.js";
+import { Effect as d, Layer as f } from "effect";
+//#region src/economyPort.fixture.ts
+var p = (p) => {
+	let m = r(p, [
+		"currencies",
+		"allowedServices",
+		"now"
+	]), h = a(m.currencies), g = new Set(n(m.allowedServices ?? [], 256).map((e) => i(e))), _ = m.now ?? (() => 0);
+	if (typeof _ != "function") throw t("invalid_input");
+	let v = _, y = !1, b = /* @__PURE__ */ new Map(), x = /* @__PURE__ */ new Map(), S = (e) => {
+		if (e.type !== "system" && !(e.type === "service" && g.has(e.service))) throw t("forbidden");
+	}, C = (e, t, n) => JSON.stringify([
+		i(e),
+		c(t),
+		i(n)
+	]), w = (e) => {
+		let n = h.find((t) => t.id === i(e));
+		if (!n) throw t("invalid_currency");
+		return n;
+	}, T = (n) => n instanceof e ? n : t("invalid_input"), E = (e) => {
+		try {
+			return e();
+		} catch (e) {
+			return d.fail(T(e));
+		}
+	}, D = (e) => d.try({
+		try: () => {
+			if (y) throw t("unavailable");
+			return e();
+		},
+		catch: T
+	}), O = (e, t, n) => {
+		let r = 0n, i = 0;
+		for (let { plan: a } of x.values()) if (a.tenantId === e && a.currency === n) for (let e of a.postings) c(e.account) === c(t) && (r += BigInt(e.credit) - BigInt(e.debit), i++);
+		return {
+			ledgerBalance: r.toString(),
+			ledgerRows: i
+		};
+	}, k = (e) => (n, r, a, o) => E(() => {
+		let c = structuredClone(n), l = s(a), u = i(o), d = i(r);
+		return D(() => {
+			if (S(c), w(u), l.kind !== "wallet") throw t("invalid_input");
+			let n = C(d, l, u), r = b.get(n), i = r?.balance ?? "0", a = O(d, l, u), o = i === a.ledgerBalance;
+			return e && !o && b.set(n, {
+				balance: a.ledgerBalance,
+				updatedAt: r?.updatedAt ?? 0
+			}), Object.freeze({
+				currency: u,
+				balance: e ? a.ledgerBalance : i,
+				...a,
+				matches: e || o
+			});
+		});
+	}), A = Object.freeze({
+		transfer: (e, n) => E(() => {
+			let r = structuredClone(e), i = l(n);
+			return D(() => {
+				S(r);
+				let e = w(i.currency), n = JSON.stringify([i.tenantId, i.requestId]), a = x.get(n);
+				if (a) {
+					if (JSON.stringify(a.plan) !== JSON.stringify(i)) throw t("conflict");
+					return a.receipt;
+				}
+				let s = i.postings.filter((e) => e.account.kind === "wallet").map((t) => {
+					let n = C(i.tenantId, t.account, i.currency);
+					return {
+						identity: n,
+						balance: o(b.get(n)?.balance ?? "0", t, e)
+					};
+				}), c = v();
+				if (!Number.isSafeInteger(c) || c < 0 || c > 864e13) throw t("unavailable");
+				if (s.some((e) => (b.get(e.identity)?.updatedAt ?? 0) > c)) throw t("invalid_record");
+				let l = Object.freeze({
+					txId: `fixture.tx.${x.size + 1}`,
+					currency: i.currency,
+					amount: i.amount,
+					at: c
+				});
+				for (let e of s) b.set(e.identity, {
+					balance: e.balance,
+					updatedAt: c
+				});
+				return x.set(n, {
+					plan: i,
+					receipt: l
+				}), l;
+			});
+		}),
+		mine: (e) => E(() => {
+			let n = structuredClone(e);
+			return D(() => {
+				if (n.type !== "user") throw t("forbidden");
+				let e = {
+					kind: "wallet",
+					ownerKind: "player",
+					ownerId: i(n.id)
+				}, r = i(n.tenantId);
+				return Object.freeze(h.map((t) => {
+					let n = b.get(C(r, e, t.id));
+					return Object.freeze({
+						currency: t.id,
+						balance: n?.balance ?? "0",
+						updatedAt: n?.updatedAt ?? null
+					});
+				}));
+			});
+		}),
+		auditWallet: k(!1),
+		rebuildWallet: k(!0)
+	}), j = d.sync(() => {
+		y = !0, b.clear(), x.clear();
+	});
+	return Object.freeze({
+		service: A,
+		layer: f.succeed(u, A),
+		close: j
+	});
+};
+//#endregion
+export { p as economyPortFixture };

package/dist/errors.d.ts

@@ -0,0 +1,14 @@
+import { Schema } from 'effect';
+import { YieldableError } from 'effect/Cause';
+
+/** Redacted codes; never carries owners, amounts or provider payloads. */
+export declare class EconomyError extends EconomyError_base {
+}
+
+export declare const economyError: (code: EconomyError["code"]) => EconomyError;
+
+declare const EconomyError_base: Schema.Class<EconomyError, Schema.TaggedStruct<"EconomyError", {
+    readonly code: Schema.Literals<readonly ["invalid_currency", "invalid_amount", "overflow", "invalid_price", "real_money_disabled", "invalid_input", "invalid_record", "currency_cap_reached", "insufficient_funds", "conflict", "forbidden", "unavailable", "not_found", "erased", "limit_exceeded", "already_redeemed"]>;
+}>, YieldableError>;
+
+export { }

package/dist/errors.js

@@ -0,0 +1,22 @@
+import { Schema as e } from "effect";
+//#region src/errors.ts
+var t = class extends e.TaggedError()("EconomyError", { code: e.Literals([
+	"invalid_currency",
+	"invalid_amount",
+	"overflow",
+	"invalid_price",
+	"real_money_disabled",
+	"invalid_input",
+	"invalid_record",
+	"currency_cap_reached",
+	"insufficient_funds",
+	"conflict",
+	"forbidden",
+	"unavailable",
+	"not_found",
+	"erased",
+	"limit_exceeded",
+	"already_redeemed"
+]) }) {}, n = (e) => new t({ code: e });
+//#endregion
+export { t as EconomyError, n as economyError };

package/dist/events.d.ts

@@ -0,0 +1,46 @@
+import { DeclaredAccess } from '@voltro/protocol';
+import { EventDescriptor } from '@voltro/protocol';
+import { Schema } from 'effect';
+
+/** Guarded server-produced metadata. Ephemeral listeners are not the durable SQL audience. */
+export declare const economyRefunded: EventDescriptor<"economy.refunded", Schema.Struct<{
+    readonly subjectId: Schema.String;
+}>, Schema.Struct<{
+    readonly eventId: Schema.String;
+    readonly orderId: Schema.String;
+    readonly sequence: Schema.Number;
+    readonly state: Schema.Literals<readonly ["active", "partially-refunded", "revoked"]>;
+    readonly refundNumerator: Schema.Number;
+    readonly refundDenominator: Schema.Number;
+    readonly observedAt: Schema.Number;
+}>, DeclaredAccess<{
+    readonly subjectId: string;
+}>>;
+
+export declare const economyRefundReversed: EventDescriptor<"economy.refundReversed", Schema.Struct<{
+    readonly subjectId: Schema.String;
+}>, Schema.Struct<{
+    readonly eventId: Schema.String;
+    readonly orderId: Schema.String;
+    readonly sequence: Schema.Number;
+    readonly state: Schema.Literals<readonly ["active", "partially-refunded", "revoked"]>;
+    readonly refundNumerator: Schema.Number;
+    readonly refundDenominator: Schema.Number;
+    readonly observedAt: Schema.Number;
+}>, DeclaredAccess<{
+    readonly subjectId: string;
+}>>;
+
+export declare type IapRefundEventPayload = typeof IapRefundEventPayloadSchema.Type;
+
+export declare const IapRefundEventPayloadSchema: Schema.Struct<{
+    readonly eventId: Schema.String;
+    readonly orderId: Schema.String;
+    readonly sequence: Schema.Number;
+    readonly state: Schema.Literals<readonly ["active", "partially-refunded", "revoked"]>;
+    readonly refundNumerator: Schema.Number;
+    readonly refundDenominator: Schema.Number;
+    readonly observedAt: Schema.Number;
+}>;
+
+export { }

package/dist/events.js

@@ -0,0 +1 @@
+export { IapRefundEventPayloadSchema, economyRefundReversed, economyRefunded } from "./iapRefundEvents.js";