@mpgd/catalog 0.5.2 → 0.7.0

package/catalog.json

@@ -1,5 +1,5 @@
 {
-  "version": "2026-07-16",
+  "version": "2026-08-11",
   "products": [
     {
       "id": "COINS_100",
@@ -13,6 +13,7 @@
         "android": "coins_100",
         "ios": "com.mpgd.game.coins100",
         "ait": "coins_100",
+        "microsoft-store": "coins_100",
         "verse8": "coins-100"
       }
     },
@@ -28,6 +29,7 @@
         "android": "coins_500",
         "ios": "com.mpgd.game.coins500",
         "ait": "coins_500",
+        "microsoft-store": "coins_500",
         "verse8": "coins-500"
       }
     },

package/dist/index.d.ts

@@ -39,13 +39,19 @@ export type AdReward = {
   readonly amount: number;
   readonly currency: 'coin' | 'gem';
 };
-export interface AdPlacementEntry {
+interface AdPlacementEntryBase {
   readonly id: LogicalAdPlacementId;
-  readonly type: 'rewarded' | 'interstitial';
-  readonly reward?: AdReward;
   readonly frequencyCap: FrequencyCap;
   readonly platformPlacementIds: Partial<Record<AdPlacementTarget, string>>;
 }
+export type AdPlacementEntry = (AdPlacementEntryBase & {
+  readonly type: 'rewarded';
+  readonly reward?: AdReward;
+}) | (AdPlacementEntryBase & {
+  readonly type: 'interstitial' | 'banner';
+  /** Non-rewarding placements must never describe a game grant. */
+  readonly reward?: never;
+});
 export interface AdPlacements {
   readonly version: string;
   readonly placements: readonly AdPlacementEntry[];
@@ -55,3 +61,4 @@ export declare function assertProductCatalog(input: unknown): ProductCatalog;
 export declare function assertAdPlacements(input: unknown): AdPlacements;
 export declare function resolveProductPlatformId(product: ProductCatalogEntry, target: CatalogTarget): string | undefined;
 export declare function resolveAdPlacementPlatformId(placement: AdPlacementEntry, target: AdPlacementTarget): string | undefined;
+export {};

package/dist/index.js

@@ -188,14 +188,15 @@ const assertProductCatalogShape = (() => {
 })();
 const assertAdPlacementsShape = (() => {
     const _ip0 = input => "number" === typeof input["amount"];
-    const _ae0 = "(undefined | { readonly type: \"continue\"; readonly amount: number; } | { readonly type: \"currency\"; readonly amount: number; readonly currency: \"coin\" | \"gem\"; })";
+    const _ae0 = "(AdPlacementEntryBase & { readonly type: \"banner\" | \"interstitial\"; readonly reward?: never; } | AdPlacementEntryBase & { readonly type: \"rewarded\"; readonly reward?: AdReward; })";
+    const _ae1 = "(undefined | { readonly type: \"continue\"; readonly amount: number; } | { readonly type: \"currency\"; readonly amount: number; readonly currency: \"coin\" | \"gem\"; })";
     const _ap0 = (input, _path, _exceptionable = true) => "number" === typeof input["amount"] || _assertGuard_1._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".amount",
         expected: "number",
         value: input["amount"]
     }, _errorFactory);
-    const _ae1 = "({ readonly type: \"continue\"; readonly amount: number; } | { readonly type: \"currency\"; readonly amount: number; readonly currency: \"coin\" | \"gem\"; })";
+    const _ae2 = "({ readonly type: \"continue\"; readonly amount: number; } | { readonly type: \"currency\"; readonly amount: number; readonly currency: \"coin\" | \"gem\"; })";
     const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.version || _assertGuard_1._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".version",
@@ -209,12 +210,12 @@ const assertAdPlacementsShape = (() => {
     }, _errorFactory)) && input.placements.every((elem, _index2) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".placements[" + _index2 + "]",
-        expected: "AdPlacementEntry",
+        expected: _ae0,
         value: elem
-    }, _errorFactory)) && _ao1(elem, _path + ".placements[" + _index2 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+    }, _errorFactory)) && _au0(elem, _path + ".placements[" + _index2 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".placements[" + _index2 + "]",
-        expected: "AdPlacementEntry",
+        expected: _ae0,
         value: elem
     }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
         method: "typia.createAssert",
@@ -222,32 +223,33 @@ const assertAdPlacementsShape = (() => {
         expected: "ReadonlyArray<AdPlacementEntry>",
         value: input.placements
     }, _errorFactory));
-    const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || _assertGuard_1._assertGuard(_exceptionable, {
-        method: "typia.createAssert",
-        path: _path + ".id",
-        expected: "string",
-        value: input.id
-    }, _errorFactory)) && ("interstitial" === input.type || "rewarded" === input.type || _assertGuard_1._assertGuard(_exceptionable, {
+    const _ao1 = (input, _path, _exceptionable = true) => _ao2(input, _path, true && _exceptionable) && (("rewarded" === input.type || _assertGuard_1._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".type",
-        expected: "(\"interstitial\" | \"rewarded\")",
+        expected: "\"rewarded\"",
         value: input.type
     }, _errorFactory)) && (undefined === input.reward || ("object" === typeof input.reward && null !== input.reward || _assertGuard_1._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".reward",
-        expected: _ae0,
+        expected: _ae1,
         value: input.reward
-    }, _errorFactory)) && _au0(input.reward, _path + ".reward", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+    }, _errorFactory)) && _au1(input.reward, _path + ".reward", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".reward",
-        expected: _ae0,
+        expected: _ae1,
         value: input.reward
+    }, _errorFactory)));
+    const _ao2 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".id",
+        expected: "string",
+        value: input.id
     }, _errorFactory)) && (("object" === typeof input.frequencyCap && null !== input.frequencyCap || _assertGuard_1._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".frequencyCap",
         expected: "FrequencyCap",
         value: input.frequencyCap
-    }, _errorFactory)) && _ao4(input.frequencyCap, _path + ".frequencyCap", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+    }, _errorFactory)) && _ao3(input.frequencyCap, _path + ".frequencyCap", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".frequencyCap",
         expected: "FrequencyCap",
@@ -257,30 +259,13 @@ const assertAdPlacementsShape = (() => {
         path: _path + ".platformPlacementIds",
         expected: "Partial<Record<string, string>>",
         value: input.platformPlacementIds
-    }, _errorFactory)) && _ao5(input.platformPlacementIds, _path + ".platformPlacementIds", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+    }, _errorFactory)) && _ao4(input.platformPlacementIds, _path + ".platformPlacementIds", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".platformPlacementIds",
         expected: "Partial<Record<string, string>>",
         value: input.platformPlacementIds
     }, _errorFactory));
-    const _ao2 = (input, _path, _exceptionable = true) => ("continue" === input.type || _assertGuard_1._assertGuard(_exceptionable, {
-        method: "typia.createAssert",
-        path: _path + ".type",
-        expected: "\"continue\"",
-        value: input.type
-    }, _errorFactory)) && _ap0(input, _path, true && _exceptionable);
-    const _ao3 = (input, _path, _exceptionable = true) => ("currency" === input.type || _assertGuard_1._assertGuard(_exceptionable, {
-        method: "typia.createAssert",
-        path: _path + ".type",
-        expected: "\"currency\"",
-        value: input.type
-    }, _errorFactory)) && _ap0(input, _path, true && _exceptionable) && ("coin" === input.currency || "gem" === input.currency || _assertGuard_1._assertGuard(_exceptionable, {
-        method: "typia.createAssert",
-        path: _path + ".currency",
-        expected: "(\"coin\" | \"gem\")",
-        value: input.currency
-    }, _errorFactory));
-    const _ao4 = (input, _path, _exceptionable = true) => ("number" === typeof input.cooldownSeconds || _assertGuard_1._assertGuard(_exceptionable, {
+    const _ao3 = (input, _path, _exceptionable = true) => ("number" === typeof input.cooldownSeconds || _assertGuard_1._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".cooldownSeconds",
         expected: "number",
@@ -296,7 +281,7 @@ const assertAdPlacementsShape = (() => {
         expected: "(number | undefined)",
         value: input.minStageInterval
     }, _errorFactory));
-    const _ao5 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every(key => {
+    const _ao4 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every(key => {
         const value = input[key];
         if (undefined === value)
             return true;
@@ -307,35 +292,91 @@ const assertAdPlacementsShape = (() => {
             value: value
         }, _errorFactory);
     });
+    const _ao5 = (input, _path, _exceptionable = true) => ("continue" === input.type || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".type",
+        expected: "\"continue\"",
+        value: input.type
+    }, _errorFactory)) && _ap0(input, _path, true && _exceptionable);
+    const _ao6 = (input, _path, _exceptionable = true) => ("currency" === input.type || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".type",
+        expected: "\"currency\"",
+        value: input.type
+    }, _errorFactory)) && _ap0(input, _path, true && _exceptionable) && ("coin" === input.currency || "gem" === input.currency || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".currency",
+        expected: "(\"coin\" | \"gem\")",
+        value: input.currency
+    }, _errorFactory));
+    const _ao7 = (input, _path, _exceptionable = true) => _ao2(input, _path, true && _exceptionable) && (("banner" === input.type || "interstitial" === input.type || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".type",
+        expected: "(\"banner\" | \"interstitial\")",
+        value: input.type
+    }, _errorFactory)) && ((null !== input.reward || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".reward",
+        expected: "undefined",
+        value: input.reward
+    }, _errorFactory)) && (undefined === input.reward || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".reward",
+        expected: "undefined",
+        value: input.reward
+    }, _errorFactory))));
     const _au0 = (input, _path, _exceptionable = true) => (() => {
+        if ("banner" === input.type || "interstitial" === input.type)
+            return _ao7(input, _path, true && _exceptionable);
+        else if ("rewarded" === input.type)
+            return _ao1(input, _path, true && _exceptionable);
+        else
+            return _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.createAssert",
+                path: _path,
+                expected: _ae0,
+                value: input
+            }, _errorFactory);
+    })();
+    const _au1 = (input, _path, _exceptionable = true) => (() => {
         if ("continue" === input.type)
-            return _ao2(input, _path, true && _exceptionable);
+            return _ao5(input, _path, true && _exceptionable);
         else if ("currency" === input.type)
-            return _ao3(input, _path, true && _exceptionable);
+            return _ao6(input, _path, true && _exceptionable);
         else
             return _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.createAssert",
                 path: _path,
-                expected: _ae1,
+                expected: _ae2,
                 value: input
             }, _errorFactory);
     })();
-    const _io0 = input => "string" === typeof input.version && (Array.isArray(input.placements) && input.placements.every(elem => "object" === typeof elem && null !== elem && _io1(elem)));
-    const _io1 = input => "string" === typeof input.id && ("interstitial" === input.type || "rewarded" === input.type) && (undefined === input.reward || "object" === typeof input.reward && null !== input.reward && _iu0(input.reward)) && ("object" === typeof input.frequencyCap && null !== input.frequencyCap && _io4(input.frequencyCap)) && ("object" === typeof input.platformPlacementIds && null !== input.platformPlacementIds && false === Array.isArray(input.platformPlacementIds) && _io5(input.platformPlacementIds));
-    const _io2 = input => "continue" === input.type && _ip0(input);
-    const _io3 = input => "currency" === input.type && _ip0(input) && ("coin" === input.currency || "gem" === input.currency);
-    const _io4 = input => "number" === typeof input.cooldownSeconds && (undefined === input.maxPerSession || "number" === typeof input.maxPerSession) && (undefined === input.minStageInterval || "number" === typeof input.minStageInterval);
-    const _io5 = input => Object.keys(input).every(key => {
+    const _io0 = input => "string" === typeof input.version && (Array.isArray(input.placements) && input.placements.every(elem => "object" === typeof elem && null !== elem && _iu0(elem)));
+    const _io1 = input => _io2(input) && ("rewarded" === input.type && (undefined === input.reward || "object" === typeof input.reward && null !== input.reward && _iu1(input.reward)));
+    const _io2 = input => "string" === typeof input.id && ("object" === typeof input.frequencyCap && null !== input.frequencyCap && _io3(input.frequencyCap)) && ("object" === typeof input.platformPlacementIds && null !== input.platformPlacementIds && false === Array.isArray(input.platformPlacementIds) && _io4(input.platformPlacementIds));
+    const _io3 = input => "number" === typeof input.cooldownSeconds && (undefined === input.maxPerSession || "number" === typeof input.maxPerSession) && (undefined === input.minStageInterval || "number" === typeof input.minStageInterval);
+    const _io4 = input => Object.keys(input).every(key => {
         const value = input[key];
         if (undefined === value)
             return true;
         return undefined === value || "string" === typeof value;
     });
+    const _io5 = input => "continue" === input.type && _ip0(input);
+    const _io6 = input => "currency" === input.type && _ip0(input) && ("coin" === input.currency || "gem" === input.currency);
+    const _io7 = input => _io2(input) && (("banner" === input.type || "interstitial" === input.type) && (null !== input.reward && undefined === input.reward));
     const _iu0 = input => (() => {
+        if ("banner" === input.type || "interstitial" === input.type)
+            return _io7(input);
+        else if ("rewarded" === input.type)
+            return _io1(input);
+        else
+            return false;
+    })();
+    const _iu1 = input => (() => {
         if ("continue" === input.type)
-            return _io2(input);
+            return _io5(input);
         else if ("currency" === input.type)
-            return _io3(input);
+            return _io6(input);
         else
             return false;
     })();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpgd/catalog",
-  "version": "0.5.2",
+  "version": "0.7.0",
   "description": "Product catalog and ad placement configuration schemas for mpgd games.",
   "license": "MIT",
   "repository": {
@@ -39,7 +39,7 @@
   ],
   "dependencies": {
     "typia": "13.0.2",
-    "@mpgd/platform": "0.8.0"
+    "@mpgd/platform": "0.10.0"
   },
   "devDependencies": {
     "ttsc": "0.18.4",