@voltro/plugin-inventory 0.0.0-stage → 0.87.0

package/dist/server.js

@@ -0,0 +1,4 @@
+import { inventoryCatalogHeadsTable as e, inventoryCatalogLocksTable as t, inventoryCatalogRevisionsTable as n, inventoryCatalogTable as r, inventoryCatalogTables as i, inventoryCatalogVersionsTable as a, inventoryItemsTable as o, inventoryLedgerTable as s, inventoryLoadoutsTable as c, inventoryOperationsTable as l, inventoryOwnedTables as u, inventoryRecipeTables as d, inventoryRecipesTable as f, inventorySubjectsTable as p, inventoryTables as m } from "./tables.entity.js";
+import { dataStoreCatalog as h } from "./sqlCatalog.js";
+import { dataStoreInventory as g, resolveInventoryOptions as _ } from "./inventoryStore.js";
+export { h as dataStoreCatalog, g as dataStoreInventory, e as inventoryCatalogHeadsTable, t as inventoryCatalogLocksTable, n as inventoryCatalogRevisionsTable, r as inventoryCatalogTable, i as inventoryCatalogTables, a as inventoryCatalogVersionsTable, o as inventoryItemsTable, s as inventoryLedgerTable, c as inventoryLoadoutsTable, l as inventoryOperationsTable, u as inventoryOwnedTables, d as inventoryRecipeTables, f as inventoryRecipesTable, p as inventorySubjectsTable, m as inventoryTables, _ as resolveInventoryOptions };

package/dist/sqlCatalog.js

@@ -0,0 +1,185 @@
+import { InventoryError as e, inventoryError as t } from "./errors.js";
+import { identifier as n, integer as r, list as i, object as a } from "./capture.js";
+import { captureCatalogItem as o, captureItemContracts as s } from "./item.js";
+import { inventoryCatalogHeadsTable as c, inventoryCatalogLocksTable as l, inventoryCatalogRevisionsTable as u, inventoryCatalogTable as d, inventoryCatalogVersionsTable as f } from "./tables.entity.js";
+import { Effect as p } from "effect";
+import { and as m, eq as h, queryFor as g } from "@voltro/database";
+import { createHash as _ } from "node:crypto";
+//#region src/sqlCatalog.ts
+var v = (e) => {
+	let n = 0, r = (e, o) => {
+		if (++n > 3e6 || o > 32) throw t("limit_exceeded");
+		if (e === null || typeof e == "string" || typeof e == "boolean" || typeof e == "number" && Number.isFinite(e) && !Object.is(e, -0)) return e;
+		if (Array.isArray(e)) return i(e, 1e5).map((e) => r(e, o + 1));
+		let s = a(e);
+		return Object.fromEntries(Object.keys(s).sort().map((e) => [e, r(s[e], o + 1)]));
+	}, o = JSON.stringify(r(e, 0));
+	if (Buffer.byteLength(o) > 67108864) throw t("limit_exceeded");
+	return _("sha256").update(o).digest("hex");
+}, y = (e, ...t) => e + v(t).slice(0, 56), b = (n) => p.tryPromise({
+	try: n,
+	catch: (n) => n instanceof e ? n : t("unavailable")
+}), x = (e) => {
+	let t = a(e, [
+		"tenantId",
+		"channel",
+		"locale"
+	]);
+	return Object.freeze({
+		tenantId: n(t.tenantId),
+		channel: n(t.channel),
+		locale: n(t.locale)
+	});
+}, S = (_, S) => {
+	let C = a(S, [
+		"items",
+		"allowedServices",
+		"maxCatalogItems",
+		"maxCatalogVersions",
+		"now"
+	]), w = s(C.items), T = new Set(i(C.allowedServices ?? [], 256).map(n)), E = r(C.maxCatalogItems ?? 1e4, 1, 1e4), D = r(C.maxCatalogVersions ?? 1e4, 1, 1e5), O = C.now ?? Date.now;
+	if (typeof O != "function") throw t("invalid_input");
+	let k = (e) => m(h("tenantId", e.tenantId), h("channel", e.channel), h("locale", e.locale)), A = (e) => y("ich_", e.tenantId, e.channel, e.locale), j = (e, n, r) => {
+		let i = o(e.definition, w);
+		if (e.tenantId !== n.tenantId || e.channel !== n.channel || e.locale !== n.locale || e.revision !== r || e.itemId !== i.id || e.id !== y("ica_", n.tenantId, n.channel, n.locale, r, i.id)) throw t("invalid_record");
+		return i;
+	};
+	return Object.freeze({
+		read: (r) => {
+			try {
+				let e = x(r);
+				return b(() => _.transactional(async (r) => {
+					let i = (await r.query(g(c).where(h("id", A(e))).limit(1).descriptor))[0];
+					if (!i) throw t("not_found");
+					if (i.tenantId !== e.tenantId || i.channel !== e.channel || i.locale !== e.locale) throw t("invalid_record");
+					let a = n(i.revision), o = (await r.query(g(u).where(h("id", y("icr_", e.tenantId, e.channel, e.locale, a))).limit(1).descriptor))[0];
+					if (!o || o.tenantId !== e.tenantId || o.channel !== e.channel || o.locale !== e.locale || o.revision !== a) throw t("invalid_record");
+					let s = await r.query(g(d).where(m(k(e), h("revision", a))).orderBy("itemId", "asc").limit(E + 1).descriptor);
+					if (s.length > E) throw t("limit_exceeded");
+					let l = Object.freeze(s.map((t) => j(t, e, a)).sort((e, t) => e.id < t.id ? -1 : +(e.id > t.id)));
+					if (new Set(l.map((e) => e.id)).size !== l.length || o.itemCount !== l.length || o.digest !== v(l)) throw t("invalid_record");
+					return Object.freeze({
+						revision: a,
+						items: l
+					});
+				}));
+			} catch (n) {
+				return p.fail(n instanceof e ? n : t("invalid_input"));
+			}
+		},
+		importSnapshot: (s, m) => {
+			try {
+				let e = structuredClone(s), p = a(m, [
+					"tenantId",
+					"channel",
+					"locale",
+					"revision",
+					"items"
+				]);
+				if (e.type !== "system" && !(e.type === "service" && T.has(e.service))) throw t("forbidden");
+				let S = x({
+					tenantId: p.tenantId,
+					channel: p.channel,
+					locale: p.locale
+				}), C = n(p.revision), k = Object.freeze(i(p.items, E).map((e) => o(e, w)).sort((e, t) => e.id < t.id ? -1 : +(e.id > t.id)));
+				if (new Set(k.map((e) => e.id)).size !== k.length) throw t("conflict");
+				let j = v(k), M = y("icl_", S.tenantId), N = y("icr_", S.tenantId, S.channel, S.locale, C), P = (e) => ({
+					id: e.id,
+					schemaVersion: e.schemaVersion,
+					kind: e.kind,
+					stackable: e.stackable,
+					maxStack: e.maxStack,
+					tradable: e.tradable,
+					equipSlot: e.equipSlot,
+					expiresAfter: e.expiresAfter
+				});
+				return b(async () => {
+					let e = r(O(), 0, 864e13);
+					try {
+						await _.insertIgnore(l.tableName, {
+							id: M,
+							tenantId: S.tenantId,
+							admission: 0
+						}, { conflictColumns: ["id"] });
+					} catch (e) {
+						if (!(await _.query(g(l).where(h("id", M)).limit(1).descriptor))[0]) throw e;
+					}
+					return _.transactional(async (n) => {
+						if (await n.updateMany(l.tableName, { admission: 0 }, { where: h("id", M) }) !== 1) throw t("unavailable");
+						if ((await n.query(g(l).where(h("id", M)).limit(1).descriptor))[0]?.tenantId !== S.tenantId) throw t("invalid_record");
+						let r = (await n.query(g(u).where(h("id", N)).limit(1).descriptor))[0];
+						if (r) {
+							if (r.tenantId !== S.tenantId || r.channel !== S.channel || r.locale !== S.locale || r.revision !== C || r.digest !== j || r.itemCount !== k.length) throw t("conflict");
+							return Object.freeze({
+								revision: C,
+								items: k
+							});
+						}
+						let i = await n.query(g(f).where(h("tenantId", S.tenantId)).orderBy("id", "asc").limit(D + 1).descriptor);
+						if (i.length > D) throw t("limit_exceeded");
+						let a = 0;
+						for (let e of k) {
+							let r = y("icv_", S.tenantId, e.id, String(e.schemaVersion)), o = i.find((e) => e.id === r);
+							if (i.some((t) => t.itemId === e.id && t.kind !== e.kind)) throw t("conflict");
+							if (o) {
+								if (o.tenantId !== S.tenantId || o.itemId !== e.id || o.schemaVersion !== e.schemaVersion || v(o.definition) !== v(P(e))) throw t("conflict");
+							} else {
+								if (i.length + ++a > D) throw t("limit_exceeded");
+								await n.insert(f.tableName, {
+									id: r,
+									tenantId: S.tenantId,
+									itemId: e.id,
+									schemaVersion: e.schemaVersion,
+									kind: e.kind,
+									definition: P(e)
+								});
+							}
+							await n.insert(d.tableName, {
+								id: y("ica_", S.tenantId, S.channel, S.locale, C, e.id),
+								tenantId: S.tenantId,
+								channel: S.channel,
+								locale: S.locale,
+								revision: C,
+								itemId: e.id,
+								definition: e
+							});
+						}
+						await n.insert(u.tableName, {
+							id: N,
+							tenantId: S.tenantId,
+							channel: S.channel,
+							locale: S.locale,
+							revision: C,
+							digest: j,
+							itemCount: k.length,
+							createdAt: new Date(e)
+						});
+						let o = A(S), s = (await n.query(g(c).where(h("id", o)).limit(1).descriptor))[0];
+						if (s) {
+							if (s.tenantId !== S.tenantId || s.channel !== S.channel || s.locale !== S.locale) throw t("invalid_record");
+							await n.update(c.tableName, o, {
+								revision: C,
+								updatedAt: new Date(e)
+							});
+						} else await n.insert(c.tableName, {
+							id: o,
+							tenantId: S.tenantId,
+							channel: S.channel,
+							locale: S.locale,
+							revision: C,
+							updatedAt: new Date(e)
+						});
+						return Object.freeze({
+							revision: C,
+							items: k
+						});
+					});
+				});
+			} catch (n) {
+				return p.fail(n instanceof e ? n : t("invalid_input"));
+			}
+		}
+	});
+};
+//#endregion
+export { x as catalogScope, S as dataStoreCatalog, v as inventoryHash, b as inventoryIo, y as inventoryKey };

package/dist/strategies.d.ts

@@ -0,0 +1,64 @@
+/** Serializable content uses a declared item's version, never a stored Schema object. */
+declare interface CatalogItem {
+    readonly id: string;
+    readonly schemaVersion: number;
+    readonly kind: ItemKind;
+    readonly stackable: boolean;
+    readonly maxStack: number;
+    readonly tradable: boolean;
+    readonly rarity: string;
+    readonly tags: readonly string[];
+    readonly equipSlot: string | null;
+    readonly expiresAfter: number | null;
+    readonly display: {
+        readonly nameKey: string;
+        readonly icon: string | null;
+    };
+    readonly attributes: JsonValue;
+    readonly instanceDefaults: JsonValue;
+}
+
+export declare const defaultExpiryPolicy: ExpiryPolicy;
+
+export declare const defaultStackPolicy: StackPolicy;
+
+export declare interface ExpiryInput {
+    readonly item: CatalogItem;
+    readonly acquiredAt: number;
+}
+
+export declare type ExpiryPolicy = (input: ExpiryInput) => number | null;
+
+declare const ITEM_KINDS: readonly ["consumable", "equipment", "cosmetic", "currencyBundle", "key", "mod"];
+
+declare type ItemKind = typeof ITEM_KINDS[number];
+
+declare type JsonValue = null | boolean | number | string | readonly JsonValue[] | {
+    readonly [key: string]: JsonValue;
+};
+
+export declare const resolveExpiry: (input: ExpiryInput, policy?: ExpiryPolicy) => number | null;
+
+/** A custom policy cannot mint, discard, duplicate or exceed a stack's cap. */
+export declare const resolveStack: (input: StackInput, policy?: StackPolicy) => StackPlan;
+
+export declare interface StackInput {
+    readonly item: CatalogItem;
+    readonly quantity: number;
+    readonly available: readonly {
+        readonly id: string;
+        readonly quantity: number;
+    }[];
+}
+
+export declare interface StackPlan {
+    readonly existing: readonly {
+        readonly id: string;
+        readonly add: number;
+    }[];
+    readonly create: readonly number[];
+}
+
+export declare type StackPolicy = (input: StackInput) => StackPlan;
+
+export { }

package/dist/strategies.js

@@ -0,0 +1,47 @@
+import { inventoryError as e } from "./errors.js";
+import { integer as t, list as n, object as r } from "./capture.js";
+//#region src/strategies.ts
+var i = (e) => {
+	let n = t(e.quantity, 1, 1e6), r = [], i = [];
+	if (e.item.stackable) for (let t of e.available) {
+		let i = Math.min(n, e.item.maxStack - t.quantity);
+		if (i > 0 && (r.push(Object.freeze({
+			id: t.id,
+			add: i
+		})), n -= i), n === 0) break;
+	}
+	for (; n > 0;) {
+		let t = Math.min(n, e.item.maxStack);
+		i.push(t), n -= t;
+	}
+	return Object.freeze({
+		existing: Object.freeze(r),
+		create: Object.freeze(i)
+	});
+}, a = (a, o = i) => {
+	let s = Object.freeze({
+		item: a.item,
+		quantity: t(a.quantity, 1, 1e6),
+		available: Object.freeze(a.available.map((e) => Object.freeze({ ...e })))
+	}), c = r(o(s), ["existing", "create"]), l = /* @__PURE__ */ new Set(), u = n(c.existing, 1e4).map((n) => {
+		let i = r(n, ["id", "add"]), a = s.available.find((e) => e.id === i.id);
+		if (!a || l.has(a.id) || !s.item.stackable) throw e("conflict");
+		return l.add(a.id), Object.freeze({
+			id: a.id,
+			add: t(i.add, 1, s.item.maxStack - a.quantity)
+		});
+	}), d = n(c.create, 1e4).map((e) => t(e, 1, s.item.maxStack));
+	if (u.reduce((e, t) => e + t.add, 0) + d.reduce((e, t) => e + t, 0) !== s.quantity) throw e("conflict");
+	return Object.freeze({
+		existing: Object.freeze(u),
+		create: Object.freeze(d)
+	});
+}, o = ({ item: e, acquiredAt: t }) => e.expiresAfter === null ? null : t + e.expiresAfter, s = (e, n = o) => {
+	let r = t(e.acquiredAt, 0, 864e13), i = n(Object.freeze({
+		item: e.item,
+		acquiredAt: r
+	}));
+	return i === null ? null : t(i, r + 1, 864e13);
+};
+//#endregion
+export { o as defaultExpiryPolicy, i as defaultStackPolicy, s as resolveExpiry, a as resolveStack };

package/dist/systemFixtures.js

@@ -0,0 +1,172 @@
+import { CraftingPort as e, defaultCraftResolver as t, resolveCraftPlan as n } from "./crafting.js";
+import { CatalogSource as r } from "./catalog.js";
+import { defaultExpiryPolicy as i, defaultStackPolicy as a, resolveExpiry as o, resolveStack as s } from "./strategies.js";
+import { InventoryPort as c } from "./port.js";
+import { craftFixture as l, inventoryFixture as u } from "./declarationFixtures.js";
+import { inventoryPortFixture as d } from "./inventoryPort.fixture.js";
+import { Effect as f } from "effect";
+import { systemSubject as p } from "@voltro/protocol";
+//#region src/systemFixtures.ts
+var m = u(), h = l(), g = h.at, _ = [...h.available, {
+	...h.available[0],
+	id: "fixture.second",
+	qty: 4
+}], v = {
+	...h,
+	available: _
+}, y = Object.freeze({
+	kind: "slot",
+	defaultImplementation: a,
+	defaultProbe: {
+		run: () => f.sync(() => s(m.stack)),
+		expected: {
+			existing: [{
+				id: "test.stack",
+				add: 2
+			}],
+			create: [10]
+		}
+	},
+	overrideProbe: {
+		run: () => f.sync(() => s(m.stack, () => ({
+			existing: [],
+			create: [6, 6]
+		}))),
+		expected: {
+			existing: [],
+			create: [6, 6]
+		}
+	}
+}), b = Object.freeze({
+	kind: "slot",
+	defaultImplementation: i,
+	defaultProbe: {
+		run: () => f.sync(() => o(m.expiry)),
+		expected: null
+	},
+	overrideProbe: {
+		run: () => f.sync(() => o(m.expiry, (e) => e.acquiredAt + 3e3)),
+		expected: m.expiry.acquiredAt + 3e3
+	}
+}), x = Object.freeze({
+	kind: "slot",
+	defaultImplementation: t,
+	defaultProbe: {
+		run: () => f.sync(() => n(v)),
+		expected: {
+			consume: [{
+				instanceId: "fixture.potion",
+				qty: 2
+			}],
+			outputs: [{
+				itemId: "test.potion",
+				qty: 1
+			}]
+		}
+	},
+	overrideProbe: {
+		run: () => f.sync(() => n(v, () => ({
+			consume: [{
+				instanceId: "fixture.second",
+				qty: 2
+			}],
+			outputs: [{
+				itemId: "test.potion",
+				qty: 1
+			}]
+		}))),
+		expected: {
+			consume: [{
+				instanceId: "fixture.second",
+				qty: 2
+			}],
+			outputs: [{
+				itemId: "test.potion",
+				qty: 1
+			}]
+		}
+	}
+}), S = d({
+	tenantId: "fixture",
+	items: [m.item],
+	content: [m.content],
+	recipes: [h.recipe],
+	now: () => g
+}).layer, C = S, w = S, T = Object.freeze({
+	kind: "port",
+	tag: r,
+	fakeLayer: w,
+	probe: {
+		run: () => f.scoped(f.gen(function* () {
+			let e = yield* (yield* r).read({
+				tenantId: "fixture",
+				channel: "live",
+				locale: "en"
+			});
+			return {
+				revision: e.revision,
+				items: e.items.map((e) => e.id)
+			};
+		}).pipe(f.provide(w))),
+		expected: {
+			revision: "fixture.r1",
+			items: ["test.potion"]
+		}
+	}
+}), E = p("inventory.system.fixture"), D = {
+	type: "user",
+	id: "a",
+	tenantId: "fixture",
+	kind: "guest"
+}, O = {
+	ownerKind: "player",
+	ownerId: "a"
+}, k = {
+	tenantId: "fixture",
+	owner: O,
+	itemId: m.item.id,
+	qty: 6,
+	requestId: "fixture.stock",
+	reason: "fixture",
+	ref: {
+		kind: "fixture",
+		id: "stock"
+	}
+}, A = Object.freeze({
+	kind: "port",
+	tag: c,
+	fakeLayer: S,
+	probe: {
+		run: () => f.scoped(f.gen(function* () {
+			let e = yield* c;
+			return yield* e.grant(E, k), (yield* e.mine(D)).reduce((e, t) => e + t.qty, 0);
+		}).pipe(f.provide(S))),
+		expected: 6
+	}
+}), j = Object.freeze({
+	kind: "port",
+	tag: e,
+	fakeLayer: C,
+	probe: {
+		run: () => f.scoped(f.gen(function* () {
+			let t = yield* c, n = yield* e;
+			yield* t.grant(E, k);
+			let r = {
+				tenantId: "fixture",
+				owner: O,
+				requestId: "fixture.craft",
+				recipeId: h.recipe.id
+			}, i = yield* n.craft(E, r), a = yield* n.craft(E, r);
+			return {
+				original: i.operationId === a.operationId,
+				quantity: (yield* t.mine(D)).reduce((e, t) => e + t.qty, 0)
+			};
+		}).pipe(f.provide(C))),
+		expected: {
+			original: !0,
+			quantity: 5
+		}
+	}
+});
+//#endregion
+export { w as catalogFakeLayer, T as catalogSourceSystemFixture, x as craftResolverSystemFixture, C as craftingFakeLayer, j as craftingPortSystemFixture, b as expiryPolicySystemFixture, S as inventoryFakeLayer, A as inventoryPortSystemFixture, y as stackPolicySystemFixture };

package/dist/tables.entity.js

@@ -0,0 +1,164 @@
+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/tables.entity.ts
+var s = () => a().maxLength(120).externalId().sensitive("pii"), c = i("_voltro_inv_catalog_locks", {
+	id: t({ prefix: "icl" }),
+	tenantId: s(),
+	admission: n().serverOnly()
+}), l = i("_voltro_inv_catalog_heads", {
+	id: t({ prefix: "ich" }),
+	tenantId: s(),
+	channel: a().maxLength(120).safe(),
+	locale: a().maxLength(120).safe(),
+	revision: a().maxLength(120).safe(),
+	updatedAt: o().safe()
+}).index([
+	"tenantId",
+	"channel",
+	"locale"
+]), u = i("_voltro_inv_catalog", {
+	id: t({ prefix: "ica" }),
+	tenantId: s(),
+	revision: a().maxLength(120).safe(),
+	channel: a().maxLength(120).safe(),
+	locale: a().maxLength(120).safe(),
+	itemId: a().maxLength(120).safe(),
+	definition: r().safe()
+}).index([
+	"tenantId",
+	"channel",
+	"locale",
+	"revision"
+]), d = i("_voltro_inv_catalog_versions", {
+	id: t({ prefix: "icv" }),
+	tenantId: s(),
+	itemId: a().maxLength(120).safe(),
+	schemaVersion: n().safe(),
+	kind: a().maxLength(32).safe(),
+	definition: r().safe()
+}).index([
+	"tenantId",
+	"itemId",
+	"schemaVersion"
+]), f = i("_voltro_inv_catalog_revisions", {
+	id: t({ prefix: "icr" }),
+	tenantId: s(),
+	revision: a().maxLength(120).safe(),
+	channel: a().maxLength(120).safe(),
+	locale: a().maxLength(120).safe(),
+	digest: a().maxLength(64).serverOnly(),
+	itemCount: n().safe(),
+	createdAt: o().safe()
+}).index("voltro_inv_catalog_revisions_scope_idx", [
+	"tenantId",
+	"channel",
+	"locale",
+	"revision"
+]), p = i("_voltro_inv_subjects", {
+	id: t({ prefix: "ivs" }),
+	tenantId: s(),
+	ownerKind: a().maxLength(16).oneOf(["player", "guild"]).safe(),
+	ownerId: a().maxLength(120).nullable().externalId().sensitive("pii"),
+	erased: e().serverOnly(),
+	admission: n().serverOnly(),
+	sequence: n().serverOnly()
+}).index([
+	"tenantId",
+	"ownerKind",
+	"ownerId"
+]), m = i("_voltro_inv_items", {
+	id: t({ prefix: "ivi" }),
+	tenantId: s(),
+	ownerKind: a().maxLength(16).oneOf(["player", "guild"]).safe(),
+	ownerId: a().maxLength(120).externalId().sensitive("pii"),
+	itemId: a().maxLength(120).safe(),
+	schemaVersion: n().safe(),
+	qty: n().safe(),
+	attributes: r().safe(),
+	acquiredAt: o().safe(),
+	expiresAt: o().nullable().safe(),
+	locked: e().safe(),
+	source: a().maxLength(120).safe()
+}).index([
+	"tenantId",
+	"ownerKind",
+	"ownerId",
+	"itemId"
+]), h = i("_voltro_inv_loadouts", {
+	id: t({ prefix: "ivl" }),
+	tenantId: s(),
+	ownerKind: a().maxLength(16).oneOf(["player", "guild"]).safe(),
+	ownerId: a().maxLength(120).externalId().sensitive("pii"),
+	slotSet: a().maxLength(120).safe(),
+	slot: a().maxLength(120).safe(),
+	instanceId: a().maxLength(64).safe()
+}).index([
+	"tenantId",
+	"ownerKind",
+	"ownerId"
+]), g = i("_voltro_inv_ledger", {
+	id: t({ prefix: "ivg" }),
+	tenantId: s(),
+	operationId: a().maxLength(64).safe(),
+	ownerKind: a().maxLength(16).oneOf(["player", "guild"]).nullable().safe(),
+	sequence: n().serverOnly(),
+	ownerId: a().maxLength(120).nullable().externalId().sensitive("pii"),
+	instanceId: a().maxLength(64).nullable().safe(),
+	itemId: a().maxLength(120).safe(),
+	delta: n().safe(),
+	reason: a().maxLength(120).safe(),
+	after: r().nullable().serverOnly(),
+	refKind: a().maxLength(120).nullable().sensitive("pii"),
+	refId: a().maxLength(120).nullable().sensitive("pii"),
+	actor: a().maxLength(120).nullable().sensitive("pii"),
+	at: o().safe()
+}).index([
+	"tenantId",
+	"ownerKind",
+	"ownerId"
+]).index(["tenantId", "operationId"]), _ = i("_voltro_inv_operations", {
+	id: t({ prefix: "ivo" }),
+	tenantId: s(),
+	state: a().maxLength(16).oneOf([
+		"pending",
+		"committed",
+		"erased"
+	]).serverOnly(),
+	ownerKey: a().maxLength(64).nullable().serverOnly(),
+	sequence: n().nullable().serverOnly(),
+	craft: r().nullable().serverOnly(),
+	reservation: r().nullable().serverOnly(),
+	transfer: r().nullable().serverOnly(),
+	digest: a().maxLength(64).nullable().serverOnly(),
+	receipt: r().nullable().safe(),
+	admission: n().serverOnly(),
+	createdAt: o().safe()
+}).index(["tenantId", "ownerKey"]), v = [
+	c,
+	l,
+	u,
+	d,
+	f
+], y = [
+	p,
+	m,
+	h,
+	g,
+	_
+], b = i("_voltro_inv_recipes", {
+	id: t({ prefix: "ivr" }),
+	tenantId: s(),
+	recipeId: a().maxLength(120).safe(),
+	version: n().safe(),
+	definition: r().serverOnly(),
+	rulesVersion: a().maxLength(120).safe()
+}).index([
+	"tenantId",
+	"recipeId",
+	"version"
+]), x = [b], S = [
+	...v,
+	...y,
+	...x
+];
+//#endregion
+export { l as inventoryCatalogHeadsTable, c as inventoryCatalogLocksTable, f as inventoryCatalogRevisionsTable, u as inventoryCatalogTable, v as inventoryCatalogTables, d as inventoryCatalogVersionsTable, m as inventoryItemsTable, g as inventoryLedgerTable, h as inventoryLoadoutsTable, _ as inventoryOperationsTable, y as inventoryOwnedTables, x as inventoryRecipeTables, b as inventoryRecipesTable, p as inventorySubjectsTable, S as inventoryTables };