@voltro/plugin-progression 0.0.0-stage → 0.87.0

package/dist/achievementTables.entity.js

@@ -0,0 +1,98 @@
+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/achievementTables.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_achievement_definitions", {
+	id: t({ prefix: "pad" }),
+	tenantId: s(),
+	achievementId: a().maxLength(120).safe(),
+	version: n().safe(),
+	config: r().serverOnly(),
+	rulesVersion: a().maxLength(120).safe(),
+	admission: n().serverOnly()
+}).index("voltro_prog_achievement_definitions_version_idx", [
+	"tenantId",
+	"achievementId",
+	"version"
+]), d = i("_voltro_prog_achievement_subjects", {
+	id: t({ prefix: "pas" }),
+	tenantId: s(),
+	ownerId: c().nullable(),
+	erased: e().serverOnly(),
+	sequence: n().serverOnly(),
+	admission: n().serverOnly(),
+	throughSequence: n().serverOnly(),
+	sourceVersion: a().maxLength(120).nullable().serverOnly(),
+	sourceDigest: a().maxLength(64).nullable().serverOnly(),
+	configDigest: a().maxLength(64).nullable().serverOnly(),
+	view: r().nullable().serverOnly()
+}).index(["tenantId", "ownerId"]), f = i("_voltro_prog_achievements", {
+	id: t({ prefix: "pau" }),
+	tenantId: s(),
+	ownerId: c(),
+	achievementId: a().maxLength(120).safe(),
+	version: n().safe(),
+	tierId: a().maxLength(120).safe(),
+	unlockedAt: o().safe(),
+	sourceSequence: n().safe(),
+	operationId: a().maxLength(64).safe()
+}).index([
+	"tenantId",
+	"ownerId",
+	"achievementId"
+]), p = i("_voltro_prog_achievement_unlock_ledger", {
+	id: t({ prefix: "pal" }),
+	tenantId: s(),
+	ownerId: c().nullable(),
+	ownerKey: l(),
+	unlockId: a().maxLength(64).safe(),
+	achievementId: a().maxLength(120).safe(),
+	version: n().safe(),
+	tierId: a().maxLength(120).safe(),
+	unlockedAt: o().safe(),
+	sourceSequence: n().safe(),
+	operationId: a().maxLength(64).safe(),
+	proof: r().nullable().serverOnly()
+}).index(["tenantId", "ownerKey"]), m = i("_voltro_prog_achievement_operations", {
+	id: t({ prefix: "pao" }),
+	tenantId: s(),
+	ownerKey: l(),
+	state: a().maxLength(16).oneOf(["committed", "erased"]).serverOnly(),
+	sequence: n().serverOnly(),
+	throughSequence: n().serverOnly(),
+	sourceVersion: a().maxLength(120).nullable().serverOnly(),
+	sourceDigest: a().maxLength(64).nullable().serverOnly(),
+	configDigest: a().maxLength(64).nullable().serverOnly(),
+	view: r().nullable().serverOnly(),
+	receipt: r().nullable().serverOnly(),
+	at: o().safe()
+}).index(["tenantId", "ownerKey"]), h = i("_voltro_prog_achievement_rewards", {
+	id: t({ prefix: "par" }),
+	tenantId: s(),
+	ownerId: c().nullable(),
+	ownerKey: l(),
+	unlockId: a().maxLength(64).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 achievementDefinitionsTable, m as achievementOperationsTable, h as achievementRewardsTable, d as achievementSubjectsTable, g as achievementTables, p as achievementUnlockLedgerTable, f as achievementsTable };

package/dist/achievements.d.ts

@@ -0,0 +1,188 @@
+import { Context } from 'effect';
+import { Effect } from 'effect';
+import { PluginPrivacyTarget } from '@voltro/protocol';
+import { Schema } from 'effect';
+import { Subject } from '@voltro/protocol';
+import { YieldableError } from 'effect/Cause';
+
+export declare interface Achievement {
+    readonly id: string;
+    readonly version: number;
+    readonly hidden: boolean;
+    readonly tiers: readonly AchievementTier[];
+}
+
+export declare type AchievementCondition = StatThreshold | CompositeCondition;
+
+export declare interface AchievementDefinition {
+    readonly id: string;
+    readonly version?: number;
+    readonly condition: AchievementCondition;
+    readonly tiers?: readonly AchievementTierDefinition[];
+    readonly hidden?: boolean;
+    readonly reward?: readonly ProgressionReward[];
+    readonly platform?: AchievementPlatform;
+}
+
+export declare interface AchievementEvaluation {
+    readonly met: boolean;
+    readonly progress: readonly AchievementProgress[];
+}
+
+export declare type AchievementEvaluator = (input: {
+    readonly condition: AchievementCondition;
+    readonly stats: readonly AchievementStat[];
+}) => AchievementEvaluation;
+
+export declare interface AchievementPlatform {
+    readonly steam?: string;
+    readonly gameCenter?: string;
+    readonly playGames?: string;
+}
+
+export declare class AchievementPort extends AchievementPort_base {
+}
+
+declare const AchievementPort_base: Context.ServiceClass<AchievementPort, "@voltro/AchievementPort", AchievementService>;
+
+export declare interface AchievementProgress extends AchievementStat {
+    readonly target: string;
+    readonly met: boolean;
+}
+
+export declare interface AchievementReceipt {
+    readonly operationId: string;
+    readonly throughSequence: number;
+    readonly unlockedIds: readonly string[];
+    readonly rewardsQueued: number;
+    readonly at: number;
+}
+
+export declare interface AchievementService {
+    readonly evaluate: (subject: Subject, input: EvaluateAchievementsInput) => Effect.Effect<AchievementReceipt, ProgressionError>;
+    readonly mine: (subject: Subject) => Effect.Effect<readonly PlayerAchievement[], ProgressionError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, ProgressionError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, ProgressionError>;
+}
+
+export declare interface AchievementStat {
+    readonly stat: string;
+    readonly period: 'lifetime' | 'season';
+    readonly seasonId: string | null;
+    readonly value: string;
+}
+
+export declare interface AchievementStatEvent extends AchievementStat {
+    readonly operationId: string;
+    readonly sequence: number;
+    readonly at: number;
+}
+
+export declare interface AchievementStatHistory {
+    readonly version: string;
+    readonly throughSequence: number;
+    readonly initial: readonly AchievementStat[];
+    readonly events: readonly AchievementStatEvent[];
+}
+
+export declare class AchievementStatSource extends AchievementStatSource_base {
+}
+
+declare const AchievementStatSource_base: Context.ServiceClass<AchievementStatSource, "@voltro/AchievementStatSource", AchievementStatSourceService>;
+
+export declare interface AchievementStatSourceService {
+    readonly history: (subject: Subject, input: {
+        readonly tenantId: string;
+        readonly ownerId: string;
+        readonly limit: number;
+    }) => Effect.Effect<AchievementStatHistory, ProgressionError>;
+}
+
+export declare interface AchievementTier {
+    readonly id: string;
+    readonly condition: AchievementCondition;
+    readonly reward: readonly ProgressionReward[];
+    readonly platform: AchievementPlatform;
+}
+
+export declare interface AchievementTierDefinition {
+    readonly id: string;
+    readonly condition: AchievementCondition;
+    readonly reward?: readonly ProgressionReward[];
+    readonly platform?: AchievementPlatform;
+}
+
+export declare const captureAchievementCondition: (input: unknown) => AchievementCondition;
+
+export declare const captureAchievementPlatform: (input: unknown) => AchievementPlatform;
+
+export declare const captureAchievementStats: (input: unknown) => readonly AchievementStat[];
+
+export declare const composite: (conditions: readonly AchievementCondition[], mode?: "all" | "any") => AchievementCondition;
+
+export declare interface CompositeCondition {
+    readonly kind: 'composite';
+    readonly mode: 'all' | 'any';
+    readonly conditions: readonly AchievementCondition[];
+}
+
+export declare const defaultAchievementEvaluator: AchievementEvaluator;
+
+export declare const defineAchievement: (input: AchievementDefinition | Achievement) => Achievement;
+
+export declare interface EvaluateAchievementsInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly requestId: string;
+}
+
+export declare interface PlayerAchievement {
+    readonly achievementId: string;
+    readonly version: number;
+    readonly tierId: string;
+    readonly unlocked: boolean;
+    readonly unlockedAt: number | null;
+    readonly progress: readonly AchievementProgress[];
+    readonly platform: AchievementPlatform | null;
+}
+
+declare class ProgressionError extends ProgressionError_base {
+}
+
+declare const ProgressionError_base: Schema.Class<ProgressionError, Schema.TaggedStruct<"ProgressionError", {
+    readonly code: Schema.Literals<readonly ["invalid_input", "invalid_record", "invalid_curve", "invalid_reward", "invalid_track", "invalid_stat", "overflow", "insufficient_resource", "forbidden", "conflict", "erased", "not_found", "limit_exceeded", "unavailable"]>;
+}>, YieldableError>;
+
+declare type ProgressionReward = {
+    readonly kind: 'currency';
+    readonly currency: string;
+    readonly amount: string;
+} | {
+    readonly kind: 'item';
+    readonly itemId: string;
+    readonly qty: number;
+} | {
+    readonly kind: 'xp';
+    readonly trackId: string;
+    readonly amount: string;
+};
+
+declare type ProgressValue = string | number | bigint;
+
+/** A custom evaluator may change fulfillment; it must retain truthful threshold progress. */
+export declare const resolveAchievementEvaluation: (condition: AchievementCondition, stats: readonly AchievementStat[], slot?: AchievementEvaluator) => AchievementEvaluation;
+
+export declare const statAtLeast: (stat: string, target: ProgressValue, scope?: {
+    readonly period?: "lifetime" | "season";
+    readonly seasonId?: string | null;
+}) => StatThreshold;
+
+export declare interface StatThreshold {
+    readonly kind: 'statAtLeast';
+    readonly stat: string;
+    readonly target: string;
+    readonly period: 'lifetime' | 'season';
+    readonly seasonId: string | null;
+}
+
+export { }

package/dist/achievements.js

@@ -0,0 +1,205 @@
+import { progressionError as e } from "./errors.js";
+import { identifier as t, integer as n, list as r, object as i, progressValue as a } from "./capture.js";
+import { captureRewards as o } from "./reward.js";
+import { Context as s } from "effect";
+//#region src/achievements.ts
+var c = (n, r, o = {}) => {
+	let s = i(o, ["period", "seasonId"]), c = s.period ?? "lifetime", l = a(r);
+	if (c !== "lifetime" && c !== "season" || l === 0n || c === "lifetime" && s.seasonId !== void 0 && s.seasonId !== null) throw e("invalid_input");
+	return Object.freeze({
+		kind: "statAtLeast",
+		stat: t(n),
+		target: String(l),
+		period: c,
+		seasonId: c === "season" ? t(s.seasonId) : null
+	});
+}, l = (n) => {
+	let a = 0, o = (n, s) => {
+		if (s > 8) throw e("limit_exceeded");
+		let l = i(n, [
+			"kind",
+			"stat",
+			"target",
+			"period",
+			"seasonId",
+			"mode",
+			"conditions"
+		]);
+		if (l.kind === "statAtLeast") {
+			if (++a > 64 || Object.keys(l).some((e) => ![
+				"kind",
+				"stat",
+				"target",
+				"period",
+				"seasonId"
+			].includes(e))) throw e("invalid_input");
+			return c(t(l.stat), l.target, {
+				period: l.period,
+				seasonId: l.seasonId
+			});
+		}
+		if (l.kind !== "composite" || l.mode !== "all" && l.mode !== "any" || Object.keys(l).some((e) => ![
+			"kind",
+			"mode",
+			"conditions"
+		].includes(e))) throw e("invalid_input");
+		let u = r(l.conditions, 64).map((e) => o(e, s + 1));
+		if (u.length === 0) throw e("invalid_input");
+		return Object.freeze({
+			kind: "composite",
+			mode: l.mode,
+			conditions: Object.freeze(u)
+		});
+	};
+	return o(n, 0);
+}, u = (e, t = "all") => l({
+	kind: "composite",
+	mode: t,
+	conditions: e
+}), d = (e) => {
+	let n = i(e, [
+		"steam",
+		"gameCenter",
+		"playGames"
+	]);
+	return Object.freeze(Object.fromEntries(Object.entries(n).map(([e, n]) => [e, t(n)])));
+}, f = (a) => {
+	let s = i(a, [
+		"id",
+		"version",
+		"condition",
+		"tiers",
+		"hidden",
+		"reward",
+		"platform"
+	]);
+	if (s.condition === void 0) {
+		if (s.reward !== void 0 || s.platform !== void 0 || typeof s.hidden != "boolean") throw e("invalid_input");
+		let a = Object.freeze(r(s.tiers, 32).map((e) => {
+			let n = i(e, [
+				"id",
+				"condition",
+				"reward",
+				"platform"
+			]);
+			return Object.freeze({
+				id: t(n.id),
+				condition: l(n.condition),
+				reward: o(n.reward, 64),
+				platform: d(n.platform)
+			});
+		}));
+		if (a[0]?.id !== "base" || new Set(a.map((e) => e.id)).size !== a.length) throw e("invalid_input");
+		return Object.freeze({
+			id: t(s.id),
+			version: n(s.version, 1, 1e6),
+			hidden: s.hidden,
+			tiers: a
+		});
+	}
+	let c = l(s.condition);
+	if (s.hidden !== void 0 && typeof s.hidden != "boolean") throw e("invalid_input");
+	let f = [Object.freeze({
+		id: "base",
+		condition: c,
+		reward: o(s.reward ?? [], 64),
+		platform: d(s.platform ?? {})
+	})];
+	for (let e of r(s.tiers ?? [], 31)) {
+		let n = i(e, [
+			"id",
+			"condition",
+			"reward",
+			"platform"
+		]);
+		f.push(Object.freeze({
+			id: t(n.id),
+			condition: u([c, l(n.condition)]),
+			reward: o(n.reward ?? [], 64),
+			platform: d(n.platform ?? {})
+		}));
+	}
+	if (new Set(f.map((e) => e.id)).size !== f.length) throw e("invalid_input");
+	return Object.freeze({
+		id: t(s.id),
+		version: n(s.version ?? 1, 1, 1e6),
+		hidden: s.hidden ?? !1,
+		tiers: Object.freeze(f)
+	});
+}, p = (n) => {
+	let o = r(n, 4096).map((n) => {
+		let r = i(n, [
+			"stat",
+			"period",
+			"seasonId",
+			"value"
+		]), o = r.period;
+		if (o !== "lifetime" && o !== "season" || o === "lifetime" && r.seasonId !== null) throw e("invalid_input");
+		return Object.freeze({
+			stat: t(r.stat),
+			period: o,
+			seasonId: o === "season" ? t(r.seasonId) : null,
+			value: String(a(r.value))
+		});
+	});
+	if (new Set(o.map((e) => JSON.stringify([
+		e.stat,
+		e.period,
+		e.seasonId
+	]))).size !== o.length) throw e("invalid_input");
+	return Object.freeze(o);
+}, m = (e) => {
+	let t = l(e.condition), n = p(e.stats), r = [], i = (e) => {
+		if (e.kind === "composite") {
+			let t = e.conditions.map(i);
+			return e.mode === "all" ? t.every(Boolean) : t.some(Boolean);
+		}
+		let t = n.find((t) => t.stat === e.stat && t.period === e.period && t.seasonId === e.seasonId)?.value ?? "0", a = BigInt(t) >= BigInt(e.target);
+		return r.push(Object.freeze({
+			stat: e.stat,
+			period: e.period,
+			seasonId: e.seasonId,
+			value: t,
+			target: e.target,
+			met: a
+		})), a;
+	}, a = i(t);
+	return Object.freeze({
+		met: a,
+		progress: Object.freeze(r)
+	});
+}, h = (t, n, o = m) => {
+	let s = Object.freeze({
+		condition: l(t),
+		stats: p(n)
+	}), c = m(s), u = i(o(s), ["met", "progress"]);
+	if (typeof u.met != "boolean") throw e("invalid_input");
+	let d = r(u.progress, 64).map((t) => {
+		let n = i(t, [
+			"stat",
+			"period",
+			"seasonId",
+			"value",
+			"target",
+			"met"
+		]);
+		if (typeof n.met != "boolean") throw e("invalid_input");
+		return Object.freeze({
+			...p([{
+				stat: n.stat,
+				period: n.period,
+				seasonId: n.seasonId,
+				value: n.value
+			}])[0],
+			target: String(a(n.target)),
+			met: n.met
+		});
+	});
+	if (JSON.stringify(d) !== JSON.stringify(c.progress)) throw e("invalid_input");
+	return Object.freeze({
+		met: u.met,
+		progress: Object.freeze(d)
+	});
+}, g = class extends s.Service()("@voltro/AchievementStatSource") {}, _ = class extends s.Service()("@voltro/AchievementPort") {};
+//#endregion
+export { _ as AchievementPort, g as AchievementStatSource, l as captureAchievementCondition, d as captureAchievementPlatform, p as captureAchievementStats, u as composite, m as defaultAchievementEvaluator, f as defineAchievement, h as resolveAchievementEvaluation, c as statAtLeast };

package/dist/capture.js

@@ -0,0 +1,64 @@
+import { progressionError as e } from "./errors.js";
+//#region src/capture.ts
+var t = (t, n) => {
+	if (!t || typeof t != "object" || Array.isArray(t)) throw e("invalid_input");
+	let r = Object.getPrototypeOf(t);
+	if (r !== Object.prototype && r !== null) throw e("invalid_input");
+	let i = Object.create(null), a = Object.getOwnPropertyDescriptors(t);
+	for (let t of Reflect.ownKeys(a)) {
+		let r = typeof t == "string" ? a[t] : void 0;
+		if (typeof t != "string" || n && !n.includes(t) || !r || !("value" in r) || !r.enumerable) throw e("invalid_input");
+		i[t] = r.value;
+	}
+	return Object.freeze(i);
+}, n = (t) => {
+	if (typeof t != "string" || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,119}$/.test(t)) throw e("invalid_input");
+	return t;
+}, r = (t, n, r) => {
+	if (typeof t != "number" || !Number.isSafeInteger(t) || Object.is(t, -0) || t < n || t > r) throw e("invalid_input");
+	return t;
+}, i = (t, n) => {
+	if (!Array.isArray(t) || t.length > n) throw e("invalid_input");
+	let r = Object.getOwnPropertyDescriptors(t);
+	if (Reflect.ownKeys(r).length !== t.length + 1) throw e("invalid_input");
+	return Object.freeze(Array.from({ length: t.length }, (t, n) => {
+		let i = r[String(n)];
+		if (!i || !("value" in i) || !i.enumerable) throw e("invalid_input");
+		return i.value;
+	}));
+}, a = 9223372036854775807n, o = (t) => {
+	let n;
+	if (typeof t == "bigint") n = t;
+	else if (typeof t == "number" && Number.isSafeInteger(t) && !Object.is(t, -0)) n = BigInt(t);
+	else if (typeof t == "string" && /^(0|[1-9][0-9]{0,18})$/.test(t)) n = BigInt(t);
+	else throw e("invalid_input");
+	if (n < 0n || n > 9223372036854775807n) throw e("overflow");
+	return n;
+}, s = (n) => {
+	let r = 0, a = (n, o) => {
+		if (++r > 4096 || o > 16) throw e("invalid_input");
+		if (n == null || typeof n == "boolean" || typeof n == "bigint" || typeof n == "string" && n.length <= 4096 || typeof n == "number" && Number.isFinite(n)) return n;
+		if (Array.isArray(n)) return Object.freeze(i(n, 4096).map((e) => a(e, o + 1)));
+		let s = t(n);
+		return Object.freeze(Object.fromEntries(Object.entries(s).map(([e, t]) => [e, a(t, o + 1)])));
+	};
+	return a(n, 0);
+}, c = (t, n) => {
+	if (typeof t != "object" || !t || Array.isArray(t)) throw e("invalid_input");
+	let r = Object.create(null);
+	for (let i of n) {
+		let n = t, a = !1;
+		for (let o = 0; n !== null && o < 8; o++, n = Object.getPrototypeOf(n)) {
+			let o = Object.getOwnPropertyDescriptor(n, i);
+			if (o !== void 0) {
+				if (!("value" in o) || typeof o.value != "function") throw e("invalid_input");
+				r[i] = o.value.bind(t), a = !0;
+				break;
+			}
+		}
+		if (!a) throw e("invalid_input");
+	}
+	return Object.freeze(r);
+};
+//#endregion
+export { a as MAX_PROGRESS_VALUE, s as captureArguments, c as captureMethods, n as identifier, r as integer, i as list, t as object, o as progressValue };

package/dist/cmsQuests.d.ts

@@ -0,0 +1,91 @@
+import { ContentEntities } from '@voltro/cms';
+import { ContentType } from '@voltro/cms';
+import { DataStore } from '@voltro/database';
+import { Effect } from 'effect';
+import { Schema } from 'effect';
+import { YieldableError } from 'effect/Cause';
+
+export declare interface CmsQuestOptions {
+    readonly site: string;
+    readonly environments: Readonly<Record<string, string>>;
+    readonly maxPools?: number;
+}
+
+export declare const cmsQuestSource: (store: DataStore, input: CmsQuestOptions) => QuestSourceService;
+
+declare class ProgressionError extends ProgressionError_base {
+}
+
+declare const ProgressionError_base: Schema.Class<ProgressionError, Schema.TaggedStruct<"ProgressionError", {
+    readonly code: Schema.Literals<readonly ["invalid_input", "invalid_record", "invalid_curve", "invalid_reward", "invalid_track", "invalid_stat", "overflow", "insufficient_resource", "forbidden", "conflict", "erased", "not_found", "limit_exceeded", "unavailable"]>;
+}>, YieldableError>;
+
+export declare const progressionQuestContentTables: ContentEntities;
+
+export declare const progressionQuestContentType: ContentType;
+
+declare type ProgressionReward = {
+    readonly kind: 'currency';
+    readonly currency: string;
+    readonly amount: string;
+} | {
+    readonly kind: 'item';
+    readonly itemId: string;
+    readonly qty: number;
+} | {
+    readonly kind: 'xp';
+    readonly trackId: string;
+    readonly amount: string;
+};
+
+declare interface QuestDefinition {
+    readonly id: string;
+    readonly titleKey?: string;
+    readonly objectives: readonly QuestObjective[];
+    readonly reward: readonly ProgressionReward[];
+}
+
+declare type QuestObjective = {
+    readonly stat: string;
+    readonly target: number;
+} | {
+    readonly event: string;
+    readonly target: number;
+    readonly where?: Readonly<Record<string, QuestScalar>>;
+};
+
+declare interface QuestPool extends QuestPoolDefinition {
+    readonly version: number;
+    readonly rerolls: number;
+    readonly weights: Readonly<Record<string, number>>;
+}
+
+declare interface QuestPoolDefinition {
+    readonly id: string;
+    readonly version?: number;
+    readonly slots: number;
+    readonly rerolls?: number;
+    readonly refresh: {
+        readonly cron: string;
+        readonly timezone: string;
+    };
+    readonly quests: readonly QuestDefinition[];
+    readonly weights?: Readonly<Record<string, number>>;
+}
+
+declare type QuestScalar = string | number | boolean | null;
+
+declare interface QuestSourceScope {
+    readonly tenantId: string;
+    readonly channel: string;
+    readonly locale: string;
+}
+
+declare interface QuestSourceService {
+    readonly read: (scope: QuestSourceScope) => Effect.Effect<{
+        readonly revision: string;
+        readonly pools: readonly QuestPool[];
+    }, ProgressionError>;
+}
+
+export { }