@mpgd/cli 0.62.0 → 0.63.0

package/dist/native-build-target.js

@@ -4445,14 +4445,14 @@ function requireOutput2(result, purpose, width) {
 }
 
 // node_modules/.cache/mpgd-native-build/packages/target-config/src/index.js
-import * as _assertGuard_13 from "typia/lib/internal/_assertGuard";
-import * as _accessExpressionAsString_14 from "typia/lib/internal/_accessExpressionAsString";
-import typia5 from "typia";
+import * as _assertGuard_14 from "typia/lib/internal/_assertGuard";
+import * as _accessExpressionAsString_15 from "typia/lib/internal/_accessExpressionAsString";
+import typia6 from "typia";
 
 // node_modules/.cache/mpgd-native-build/packages/catalog/src/index.js
-import * as _assertGuard_12 from "typia/lib/internal/_assertGuard";
-import * as _accessExpressionAsString_13 from "typia/lib/internal/_accessExpressionAsString";
-import typia3 from "typia";
+import * as _assertGuard_13 from "typia/lib/internal/_assertGuard";
+import * as _accessExpressionAsString_14 from "typia/lib/internal/_accessExpressionAsString";
+import typia4 from "typia";
 
 // node_modules/.cache/mpgd-native-build/packages/platform/src/notifications.js
 import * as _isTypeUint32_1 from "typia/lib/internal/_isTypeUint32";
@@ -7977,6 +7977,11 @@ var validateShape = (() => {
   });
 })();
 
+// node_modules/.cache/mpgd-native-build/packages/catalog/src/store-listings.js
+import * as _assertGuard_12 from "typia/lib/internal/_assertGuard";
+import * as _accessExpressionAsString_13 from "typia/lib/internal/_accessExpressionAsString";
+import typia3 from "typia";
+
 // node_modules/.cache/mpgd-native-build/packages/catalog/src/index.js
 var defaultCatalogCurrencies = Object.freeze(["coin", "gem"]);
 function resolveProductPlatformId(product, target2) {
@@ -7996,7 +8001,7 @@ function normalizePlatformIdentifier(identifier) {
 
 // node_modules/.cache/mpgd-native-build/packages/target-config/src/runtime.js
 import * as _isTypeUint32_13 from "typia/lib/internal/_isTypeUint32";
-import typia4 from "typia";
+import typia5 from "typia";
 var adPlacementFeatureByType = {
   rewarded: "rewardedAds",
   interstitial: "interstitialAds",
@@ -8545,17 +8550,17 @@ function isRecord2(value) {
 // node_modules/.cache/mpgd-native-build/packages/bridge/src/index.js
 import * as _isTypeUint32_15 from "typia/lib/internal/_isTypeUint32";
 import * as _isFormatDateTime_13 from "typia/lib/internal/_isFormatDateTime";
-import * as _assertGuard_15 from "typia/lib/internal/_assertGuard";
-import * as _accessExpressionAsString_16 from "typia/lib/internal/_accessExpressionAsString";
-import typia7 from "typia";
+import * as _assertGuard_16 from "typia/lib/internal/_assertGuard";
+import * as _accessExpressionAsString_17 from "typia/lib/internal/_accessExpressionAsString";
+import typia8 from "typia";
 
 // node_modules/.cache/mpgd-native-build/packages/platform/src/commerce.js
 import * as _isTypeInt64_1 from "typia/lib/internal/_isTypeInt64";
 import * as _isTypeUint32_14 from "typia/lib/internal/_isTypeUint32";
 import * as _isFormatDateTime_12 from "typia/lib/internal/_isFormatDateTime";
-import * as _assertGuard_14 from "typia/lib/internal/_assertGuard";
-import * as _accessExpressionAsString_15 from "typia/lib/internal/_accessExpressionAsString";
-import typia6 from "typia";
+import * as _assertGuard_15 from "typia/lib/internal/_assertGuard";
+import * as _accessExpressionAsString_16 from "typia/lib/internal/_accessExpressionAsString";
+import typia7 from "typia";
 var commerceErrorCodes = Object.freeze([
   "USER_CANCELLED",
   "OUTCOME_UNKNOWN",
@@ -9252,10 +9257,10 @@ function formatError4(error) {
 }
 
 // node_modules/.cache/mpgd-native-build/tools/target/schemas.js
-import * as _assertGuard_16 from "typia/lib/internal/_assertGuard";
-import * as _accessExpressionAsString_17 from "typia/lib/internal/_accessExpressionAsString";
-import typia8 from "typia";
-var __typia_transform__accessExpressionAsString3 = _accessExpressionAsString_17._accessExpressionAsString;
+import * as _assertGuard_17 from "typia/lib/internal/_assertGuard";
+import * as _accessExpressionAsString_18 from "typia/lib/internal/_accessExpressionAsString";
+import typia9 from "typia";
+var __typia_transform__accessExpressionAsString3 = _accessExpressionAsString_18._accessExpressionAsString;
 var assertPlatformTargetsConfig = /* @__PURE__ */ (() => {
   const _ip0 = (input) => void 0 === input["assetPacks"] || "object" === typeof input["assetPacks"] && null !== input["assetPacks"] && _io3(input["assetPacks"]);
   const _ip1 = (input) => "string" === typeof input["gameApp"];
@@ -9267,75 +9272,75 @@ var assertPlatformTargetsConfig = /* @__PURE__ */ (() => {
   const _ip7 = (input) => "string" === typeof input["wrapperApp"];
   const _ip8 = (input) => "string" === typeof input["webDir"];
   const _ip9 = (input) => "string" === typeof input["output"];
-  const _ap0 = (input, _path, _exceptionable = true) => void 0 === input["assetPacks"] || ("object" === typeof input["assetPacks"] && null !== input["assetPacks"] || _assertGuard_16._assertGuard(_exceptionable, {
+  const _ap0 = (input, _path, _exceptionable = true) => void 0 === input["assetPacks"] || ("object" === typeof input["assetPacks"] && null !== input["assetPacks"] || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".assetPacks",
     expected: "(AssetPackTargetPolicy | undefined)",
     value: input["assetPacks"]
-  }, _errorFactory)) && _ao3(input["assetPacks"], _path + ".assetPacks", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao3(input["assetPacks"], _path + ".assetPacks", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".assetPacks",
     expected: "(AssetPackTargetPolicy | undefined)",
     value: input["assetPacks"]
   }, _errorFactory);
-  const _ap1 = (input, _path, _exceptionable = true) => "string" === typeof input["gameApp"] || _assertGuard_16._assertGuard(_exceptionable, {
+  const _ap1 = (input, _path, _exceptionable = true) => "string" === typeof input["gameApp"] || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".gameApp",
     expected: "string",
     value: input["gameApp"]
   }, _errorFactory);
-  const _ap2 = (input, _path, _exceptionable = true) => "string" === typeof input["adapter"] || _assertGuard_16._assertGuard(_exceptionable, {
+  const _ap2 = (input, _path, _exceptionable = true) => "string" === typeof input["adapter"] || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".adapter",
     expected: "string",
     value: input["adapter"]
   }, _errorFactory);
-  const _ap3 = (input, _path, _exceptionable = true) => void 0 === input["metadata"] || ("object" === typeof input["metadata"] && null !== input["metadata"] && false === Array.isArray(input["metadata"]) || _assertGuard_16._assertGuard(_exceptionable, {
+  const _ap3 = (input, _path, _exceptionable = true) => void 0 === input["metadata"] || ("object" === typeof input["metadata"] && null !== input["metadata"] && false === Array.isArray(input["metadata"]) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".metadata",
     expected: "(TargetReleaseMetadata | undefined)",
     value: input["metadata"]
-  }, _errorFactory)) && _ao5(input["metadata"], _path + ".metadata", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao5(input["metadata"], _path + ".metadata", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".metadata",
     expected: "(TargetReleaseMetadata | undefined)",
     value: input["metadata"]
   }, _errorFactory);
-  const _ap4 = (input, _path, _exceptionable = true) => void 0 === input["authoritativeGameServices"] || "boolean" === typeof input["authoritativeGameServices"] || _assertGuard_16._assertGuard(_exceptionable, {
+  const _ap4 = (input, _path, _exceptionable = true) => void 0 === input["authoritativeGameServices"] || "boolean" === typeof input["authoritativeGameServices"] || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".authoritativeGameServices",
     expected: "(boolean | undefined)",
     value: input["authoritativeGameServices"]
   }, _errorFactory);
-  const _ap5 = (input, _path, _exceptionable = true) => void 0 === input["integrations"] || ("object" === typeof input["integrations"] && null !== input["integrations"] && false === Array.isArray(input["integrations"]) || _assertGuard_16._assertGuard(_exceptionable, {
+  const _ap5 = (input, _path, _exceptionable = true) => void 0 === input["integrations"] || ("object" === typeof input["integrations"] && null !== input["integrations"] && false === Array.isArray(input["integrations"]) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".integrations",
     expected: "(Partial<TargetIntegrationConfig> | undefined)",
     value: input["integrations"]
-  }, _errorFactory)) && _ao6(input["integrations"], _path + ".integrations", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao6(input["integrations"], _path + ".integrations", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".integrations",
     expected: "(Partial<TargetIntegrationConfig> | undefined)",
     value: input["integrations"]
   }, _errorFactory);
-  const _ap6 = (input, _path, _exceptionable = true) => void 0 === input["icon"] || ("object" === typeof input["icon"] && null !== input["icon"] && false === Array.isArray(input["icon"]) || _assertGuard_16._assertGuard(_exceptionable, {
+  const _ap6 = (input, _path, _exceptionable = true) => void 0 === input["icon"] || ("object" === typeof input["icon"] && null !== input["icon"] && false === Array.isArray(input["icon"]) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".icon",
     expected: "(TargetIconConfig | undefined)",
     value: input["icon"]
-  }, _errorFactory)) && _ao7(input["icon"], _path + ".icon", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao7(input["icon"], _path + ".icon", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".icon",
     expected: "(TargetIconConfig | undefined)",
     value: input["icon"]
   }, _errorFactory);
-  const _ap7 = (input, _path, _exceptionable = true) => "string" === typeof input["wrapperApp"] || _assertGuard_16._assertGuard(_exceptionable, {
+  const _ap7 = (input, _path, _exceptionable = true) => "string" === typeof input["wrapperApp"] || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".wrapperApp",
     expected: "string",
     value: input["wrapperApp"]
   }, _errorFactory);
-  const _ap8 = (input, _path, _exceptionable = true) => "string" === typeof input["webDir"] || _assertGuard_16._assertGuard(_exceptionable, {
+  const _ap8 = (input, _path, _exceptionable = true) => "string" === typeof input["webDir"] || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".webDir",
     expected: "string",
@@ -9343,18 +9348,18 @@ var assertPlatformTargetsConfig = /* @__PURE__ */ (() => {
   }, _errorFactory);
   const _ae0 = '("action-required" | "approval-required" | "available" | "configuration-required" | "disabled" | "temporarily-unavailable" | "unsupported" | undefined)';
   const _ae1 = "(undefined | { readonly maskable?: string; readonly androidForeground?: string; readonly monochrome?: string; readonly background?: string; })";
-  const _ap9 = (input, _path, _exceptionable = true) => "string" === typeof input["output"] || _assertGuard_16._assertGuard(_exceptionable, {
+  const _ap9 = (input, _path, _exceptionable = true) => "string" === typeof input["output"] || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".output",
     expected: "string",
     value: input["output"]
   }, _errorFactory);
-  const _ao0 = (input, _path, _exceptionable = true) => ("object" === typeof input.targets && null !== input.targets && false === Array.isArray(input.targets) || _assertGuard_16._assertGuard(_exceptionable, {
+  const _ao0 = (input, _path, _exceptionable = true) => ("object" === typeof input.targets && null !== input.targets && false === Array.isArray(input.targets) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".targets",
     expected: "Record<string, PlatformTargetConfig>",
     value: input.targets
-  }, _errorFactory)) && _ao1(input.targets, _path + ".targets", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao1(input.targets, _path + ".targets", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".targets",
     expected: "Record<string, PlatformTargetConfig>",
@@ -9364,241 +9369,241 @@ var assertPlatformTargetsConfig = /* @__PURE__ */ (() => {
     const value = input[key];
     if (void 0 === value)
       return true;
-    return ("object" === typeof value && null !== value || _assertGuard_16._assertGuard(_exceptionable, {
+    return ("object" === typeof value && null !== value || _assertGuard_17._assertGuard(_exceptionable, {
       method: "typia.createAssert",
       path: _path + __typia_transform__accessExpressionAsString3(key),
       expected: "(AppsInTossTargetConfig | CapacitorTargetConfig | DevvitTargetConfig | MiniGameTargetConfig | WebTargetConfig)",
       value
-    }, _errorFactory)) && _au0(value, _path + __typia_transform__accessExpressionAsString3(key), _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+    }, _errorFactory)) && _au0(value, _path + __typia_transform__accessExpressionAsString3(key), _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
       method: "typia.createAssert",
       path: _path + __typia_transform__accessExpressionAsString3(key),
       expected: "(AppsInTossTargetConfig | CapacitorTargetConfig | DevvitTargetConfig | MiniGameTargetConfig | WebTargetConfig)",
       value
     }, _errorFactory);
   });
-  const _ao10 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && _ap3(input, _path, _exceptionable) && _ap4(input, _path, _exceptionable) && _ap5(input, _path, _exceptionable) && _ap6(input, _path, _exceptionable) && ("capacitor-android" === input.kind || "capacitor-ios" === input.kind || _assertGuard_16._assertGuard(_exceptionable, {
+  const _ao10 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && _ap3(input, _path, _exceptionable) && _ap4(input, _path, _exceptionable) && _ap5(input, _path, _exceptionable) && _ap6(input, _path, _exceptionable) && ("capacitor-android" === input.kind || "capacitor-ios" === input.kind || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".kind",
     expected: '("capacitor-android" | "capacitor-ios")',
     value: input.kind
-  }, _errorFactory)) && ("string" === typeof input.shellApp || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.shellApp || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".shellApp",
     expected: "string",
     value: input.shellApp
-  }, _errorFactory)) && _ap8(input, _path, _exceptionable) && ("aab" === input.artifact || "apk" === input.artifact || "ipa" === input.artifact || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ap8(input, _path, _exceptionable) && ("aab" === input.artifact || "apk" === input.artifact || "ipa" === input.artifact || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".artifact",
     expected: '("aab" | "apk" | "ipa")',
     value: input.artifact
   }, _errorFactory));
-  const _ao11 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && _ap3(input, _path, _exceptionable) && _ap4(input, _path, _exceptionable) && _ap5(input, _path, _exceptionable) && _ap6(input, _path, _exceptionable) && ("devvit-web" === input.kind || _assertGuard_16._assertGuard(_exceptionable, {
+  const _ao11 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && _ap3(input, _path, _exceptionable) && _ap4(input, _path, _exceptionable) && _ap5(input, _path, _exceptionable) && _ap6(input, _path, _exceptionable) && ("devvit-web" === input.kind || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".kind",
     expected: '"devvit-web"',
     value: input.kind
-  }, _errorFactory)) && _ap7(input, _path, _exceptionable) && _ap8(input, _path, _exceptionable) && ("devvit" === input.artifact || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ap7(input, _path, _exceptionable) && _ap8(input, _path, _exceptionable) && ("devvit" === input.artifact || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".artifact",
     expected: '"devvit"',
     value: input.artifact
-  }, _errorFactory)) && (void 0 === input.inlineEntry || "string" === typeof input.inlineEntry || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.inlineEntry || "string" === typeof input.inlineEntry || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".inlineEntry",
     expected: "(string | undefined)",
     value: input.inlineEntry
-  }, _errorFactory)) && (void 0 === input.inlineBudget || ("object" === typeof input.inlineBudget && null !== input.inlineBudget && false === Array.isArray(input.inlineBudget) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.inlineBudget || ("object" === typeof input.inlineBudget && null !== input.inlineBudget && false === Array.isArray(input.inlineBudget) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".inlineBudget",
     expected: "(DevvitInlineBudget | undefined)",
     value: input.inlineBudget
-  }, _errorFactory)) && _ao12(input.inlineBudget, _path + ".inlineBudget", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao12(input.inlineBudget, _path + ".inlineBudget", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".inlineBudget",
     expected: "(DevvitInlineBudget | undefined)",
     value: input.inlineBudget
   }, _errorFactory));
-  const _ao12 = (input, _path, _exceptionable = true) => (void 0 === input.maxGzipKb || "number" === typeof input.maxGzipKb || _assertGuard_16._assertGuard(_exceptionable, {
+  const _ao12 = (input, _path, _exceptionable = true) => (void 0 === input.maxGzipKb || "number" === typeof input.maxGzipKb || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".maxGzipKb",
     expected: "(number | undefined)",
     value: input.maxGzipKb
-  }, _errorFactory)) && (void 0 === input.forbidModules || (Array.isArray(input.forbidModules) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.forbidModules || (Array.isArray(input.forbidModules) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".forbidModules",
     expected: "(ReadonlyArray<string> | undefined)",
     value: input.forbidModules
-  }, _errorFactory)) && input.forbidModules.every((elem, _index6) => "string" === typeof elem || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && input.forbidModules.every((elem, _index6) => "string" === typeof elem || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".forbidModules[" + _index6 + "]",
     expected: "string",
     value: elem
-  }, _errorFactory)) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".forbidModules",
     expected: "(ReadonlyArray<string> | undefined)",
     value: input.forbidModules
-  }, _errorFactory)) && (void 0 === input.deferredChunks || (Array.isArray(input.deferredChunks) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.deferredChunks || (Array.isArray(input.deferredChunks) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".deferredChunks",
     expected: "(ReadonlyArray<string> | undefined)",
     value: input.deferredChunks
-  }, _errorFactory)) && input.deferredChunks.every((elem, _index7) => "string" === typeof elem || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && input.deferredChunks.every((elem, _index7) => "string" === typeof elem || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".deferredChunks[" + _index7 + "]",
     expected: "string",
     value: elem
-  }, _errorFactory)) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".deferredChunks",
     expected: "(ReadonlyArray<string> | undefined)",
     value: input.deferredChunks
   }, _errorFactory));
-  const _ao13 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && _ap3(input, _path, _exceptionable) && _ap4(input, _path, _exceptionable) && _ap5(input, _path, _exceptionable) && _ap6(input, _path, _exceptionable) && ("tiktok-minigame" === input.kind || "wechat-minigame" === input.kind || _assertGuard_16._assertGuard(_exceptionable, {
+  const _ao13 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && _ap3(input, _path, _exceptionable) && _ap4(input, _path, _exceptionable) && _ap5(input, _path, _exceptionable) && _ap6(input, _path, _exceptionable) && ("tiktok-minigame" === input.kind || "wechat-minigame" === input.kind || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".kind",
     expected: '("tiktok-minigame" | "wechat-minigame")',
     value: input.kind
-  }, _errorFactory)) && _ap9(input, _path, _exceptionable) && ("canvas" === input.renderer || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ap9(input, _path, _exceptionable) && ("canvas" === input.renderer || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".renderer",
     expected: '"canvas"',
     value: input.renderer
-  }, _errorFactory)) && ("landscape" === input.orientation || "portrait" === input.orientation || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("landscape" === input.orientation || "portrait" === input.orientation || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".orientation",
     expected: '("landscape" | "portrait")',
     value: input.orientation
-  }, _errorFactory)) && (true === input.experimental || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (true === input.experimental || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".experimental",
     expected: "true",
     value: input.experimental
-  }, _errorFactory)) && (void 0 === input.remoteAssetOrigins || (Array.isArray(input.remoteAssetOrigins) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.remoteAssetOrigins || (Array.isArray(input.remoteAssetOrigins) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".remoteAssetOrigins",
     expected: "(ReadonlyArray<string> | undefined)",
     value: input.remoteAssetOrigins
-  }, _errorFactory)) && input.remoteAssetOrigins.every((elem, _index8) => "string" === typeof elem || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && input.remoteAssetOrigins.every((elem, _index8) => "string" === typeof elem || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".remoteAssetOrigins[" + _index8 + "]",
     expected: "string",
     value: elem
-  }, _errorFactory)) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".remoteAssetOrigins",
     expected: "(ReadonlyArray<string> | undefined)",
     value: input.remoteAssetOrigins
-  }, _errorFactory)) && (("object" === typeof input.packageBudget && null !== input.packageBudget || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.packageBudget && null !== input.packageBudget || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".packageBudget",
     expected: "MiniGamePackageBudget",
     value: input.packageBudget
-  }, _errorFactory)) && _ao14(input.packageBudget, _path + ".packageBudget", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao14(input.packageBudget, _path + ".packageBudget", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".packageBudget",
     expected: "MiniGamePackageBudget",
     value: input.packageBudget
   }, _errorFactory));
-  const _ao14 = (input, _path, _exceptionable = true) => ("number" === typeof input.mainBytes || _assertGuard_16._assertGuard(_exceptionable, {
+  const _ao14 = (input, _path, _exceptionable = true) => ("number" === typeof input.mainBytes || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".mainBytes",
     expected: "number",
     value: input.mainBytes
-  }, _errorFactory)) && ("number" === typeof input.totalBytes || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("number" === typeof input.totalBytes || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".totalBytes",
     expected: "number",
     value: input.totalBytes
-  }, _errorFactory)) && (void 0 === input.independentSubpackageBytes || "number" === typeof input.independentSubpackageBytes || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.independentSubpackageBytes || "number" === typeof input.independentSubpackageBytes || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".independentSubpackageBytes",
     expected: "(number | undefined)",
     value: input.independentSubpackageBytes
   }, _errorFactory));
-  const _ao15 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && _ap3(input, _path, _exceptionable) && _ap4(input, _path, _exceptionable) && _ap5(input, _path, _exceptionable) && _ap6(input, _path, _exceptionable) && ("web" === input.kind || _assertGuard_16._assertGuard(_exceptionable, {
+  const _ao15 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && _ap3(input, _path, _exceptionable) && _ap4(input, _path, _exceptionable) && _ap5(input, _path, _exceptionable) && _ap6(input, _path, _exceptionable) && ("web" === input.kind || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".kind",
     expected: '"web"',
     value: input.kind
-  }, _errorFactory)) && _ap9(input, _path, _exceptionable) && (void 0 === input.installable || "boolean" === typeof input.installable || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ap9(input, _path, _exceptionable) && (void 0 === input.installable || "boolean" === typeof input.installable || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".installable",
     expected: "(boolean | undefined)",
     value: input.installable
-  }, _errorFactory)) && (void 0 === input.crazyGamesLaunch || "basic" === input.crazyGamesLaunch || "full" === input.crazyGamesLaunch || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.crazyGamesLaunch || "basic" === input.crazyGamesLaunch || "full" === input.crazyGamesLaunch || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".crazyGamesLaunch",
     expected: '("basic" | "full" | undefined)',
     value: input.crazyGamesLaunch
-  }, _errorFactory)) && (void 0 === input.staticDir || "string" === typeof input.staticDir || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.staticDir || "string" === typeof input.staticDir || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".staticDir",
     expected: "(string | undefined)",
     value: input.staticDir
   }, _errorFactory));
-  const _ao2 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && _ap3(input, _path, _exceptionable) && _ap4(input, _path, _exceptionable) && _ap5(input, _path, _exceptionable) && _ap6(input, _path, _exceptionable) && ("apps-in-toss" === input.kind || _assertGuard_16._assertGuard(_exceptionable, {
+  const _ao2 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && _ap3(input, _path, _exceptionable) && _ap4(input, _path, _exceptionable) && _ap5(input, _path, _exceptionable) && _ap6(input, _path, _exceptionable) && ("apps-in-toss" === input.kind || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".kind",
     expected: '"apps-in-toss"',
     value: input.kind
-  }, _errorFactory)) && _ap7(input, _path, _exceptionable) && _ap8(input, _path, _exceptionable) && (".ait" === input.artifact || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ap7(input, _path, _exceptionable) && _ap8(input, _path, _exceptionable) && (".ait" === input.artifact || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".artifact",
     expected: '".ait"',
     value: input.artifact
-  }, _errorFactory)) && (void 0 === input.navigationBar || ("object" === typeof input.navigationBar && null !== input.navigationBar && false === Array.isArray(input.navigationBar) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.navigationBar || ("object" === typeof input.navigationBar && null !== input.navigationBar && false === Array.isArray(input.navigationBar) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".navigationBar",
     expected: "(AppsInTossNavigationBarConfig | undefined)",
     value: input.navigationBar
-  }, _errorFactory)) && _ao9(input.navigationBar, _path + ".navigationBar", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao9(input.navigationBar, _path + ".navigationBar", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".navigationBar",
     expected: "(AppsInTossNavigationBarConfig | undefined)",
     value: input.navigationBar
   }, _errorFactory));
-  const _ao3 = (input, _path, _exceptionable = true) => ("packaged" === input.defaultLocation || "remote" === input.defaultLocation || _assertGuard_16._assertGuard(_exceptionable, {
+  const _ao3 = (input, _path, _exceptionable = true) => ("packaged" === input.defaultLocation || "remote" === input.defaultLocation || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".defaultLocation",
     expected: '("packaged" | "remote")',
     value: input.defaultLocation
-  }, _errorFactory)) && (void 0 === input.packs || ("object" === typeof input.packs && null !== input.packs && false === Array.isArray(input.packs) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.packs || ("object" === typeof input.packs && null !== input.packs && false === Array.isArray(input.packs) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".packs",
     expected: "(Readonly<Record<string, AssetPackLocation>> | undefined)",
     value: input.packs
-  }, _errorFactory)) && _ao4(input.packs, _path + ".packs", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao4(input.packs, _path + ".packs", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".packs",
     expected: "(Readonly<Record<string, AssetPackLocation>> | undefined)",
     value: input.packs
-  }, _errorFactory)) && (void 0 === input.offlineRequired || (Array.isArray(input.offlineRequired) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.offlineRequired || (Array.isArray(input.offlineRequired) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".offlineRequired",
     expected: "(ReadonlyArray<string> | undefined)",
     value: input.offlineRequired
-  }, _errorFactory)) && input.offlineRequired.every((elem, _index5) => "string" === typeof elem || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && input.offlineRequired.every((elem, _index5) => "string" === typeof elem || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".offlineRequired[" + _index5 + "]",
     expected: "string",
     value: elem
-  }, _errorFactory)) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".offlineRequired",
     expected: "(ReadonlyArray<string> | undefined)",
     value: input.offlineRequired
-  }, _errorFactory)) && (void 0 === input.remoteBaseUrl || "string" === typeof input.remoteBaseUrl || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.remoteBaseUrl || "string" === typeof input.remoteBaseUrl || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".remoteBaseUrl",
     expected: "(string | undefined)",
     value: input.remoteBaseUrl
-  }, _errorFactory)) && (void 0 === input.maxPackagedBytes || "number" === typeof input.maxPackagedBytes || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.maxPackagedBytes || "number" === typeof input.maxPackagedBytes || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".maxPackagedBytes",
     expected: "(number | undefined)",
     value: input.maxPackagedBytes
-  }, _errorFactory)) && ("string" === typeof input.buildConfig || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.buildConfig || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".buildConfig",
     expected: "string",
@@ -9608,158 +9613,158 @@ var assertPlatformTargetsConfig = /* @__PURE__ */ (() => {
     const value = input[key];
     if (void 0 === value)
       return true;
-    return "packaged" === value || "remote" === value || _assertGuard_16._assertGuard(_exceptionable, {
+    return "packaged" === value || "remote" === value || _assertGuard_17._assertGuard(_exceptionable, {
       method: "typia.createAssert",
       path: _path + __typia_transform__accessExpressionAsString3(key),
       expected: '("packaged" | "remote")',
       value
     }, _errorFactory);
   });
-  const _ao5 = (input, _path, _exceptionable = true) => (void 0 === input.appName || "string" === typeof input.appName || _assertGuard_16._assertGuard(_exceptionable, {
+  const _ao5 = (input, _path, _exceptionable = true) => (void 0 === input.appName || "string" === typeof input.appName || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".appName",
     expected: "(string | undefined)",
     value: input.appName
-  }, _errorFactory)) && (void 0 === input.displayName || "string" === typeof input.displayName || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.displayName || "string" === typeof input.displayName || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".displayName",
     expected: "(string | undefined)",
     value: input.displayName
-  }, _errorFactory)) && (void 0 === input.primaryColor || "string" === typeof input.primaryColor || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.primaryColor || "string" === typeof input.primaryColor || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".primaryColor",
     expected: "(string | undefined)",
     value: input.primaryColor
-  }, _errorFactory)) && (void 0 === input.packageId || "string" === typeof input.packageId || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.packageId || "string" === typeof input.packageId || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".packageId",
     expected: "(string | undefined)",
     value: input.packageId
-  }, _errorFactory)) && (void 0 === input.bundleId || "string" === typeof input.bundleId || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.bundleId || "string" === typeof input.bundleId || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".bundleId",
     expected: "(string | undefined)",
     value: input.bundleId
-  }, _errorFactory)) && (void 0 === input.sdkMajor || "number" === typeof input.sdkMajor || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.sdkMajor || "number" === typeof input.sdkMajor || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".sdkMajor",
     expected: "(number | undefined)",
     value: input.sdkMajor
-  }, _errorFactory)) && (void 0 === input.iosDeviceFamily || "iphone" === input.iosDeviceFamily || "universal" === input.iosDeviceFamily || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.iosDeviceFamily || "iphone" === input.iosDeviceFamily || "universal" === input.iosDeviceFamily || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".iosDeviceFamily",
     expected: '("iphone" | "universal" | undefined)',
     value: input.iosDeviceFamily
   }, _errorFactory));
-  const _ao6 = (input, _path, _exceptionable = true) => (void 0 === input.identityUpgrade || "action-required" === input.identityUpgrade || "approval-required" === input.identityUpgrade || "available" === input.identityUpgrade || "configuration-required" === input.identityUpgrade || "disabled" === input.identityUpgrade || "temporarily-unavailable" === input.identityUpgrade || "unsupported" === input.identityUpgrade || _assertGuard_16._assertGuard(_exceptionable, {
+  const _ao6 = (input, _path, _exceptionable = true) => (void 0 === input.identityUpgrade || "action-required" === input.identityUpgrade || "approval-required" === input.identityUpgrade || "available" === input.identityUpgrade || "configuration-required" === input.identityUpgrade || "disabled" === input.identityUpgrade || "temporarily-unavailable" === input.identityUpgrade || "unsupported" === input.identityUpgrade || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".identityUpgrade",
     expected: _ae0,
     value: input.identityUpgrade
-  }, _errorFactory)) && (void 0 === input.presentation || "action-required" === input.presentation || "approval-required" === input.presentation || "available" === input.presentation || "configuration-required" === input.presentation || "disabled" === input.presentation || "temporarily-unavailable" === input.presentation || "unsupported" === input.presentation || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.presentation || "action-required" === input.presentation || "approval-required" === input.presentation || "available" === input.presentation || "configuration-required" === input.presentation || "disabled" === input.presentation || "temporarily-unavailable" === input.presentation || "unsupported" === input.presentation || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".presentation",
     expected: _ae0,
     value: input.presentation
-  }, _errorFactory)) && (void 0 === input.sharing || "action-required" === input.sharing || "approval-required" === input.sharing || "available" === input.sharing || "configuration-required" === input.sharing || "disabled" === input.sharing || "temporarily-unavailable" === input.sharing || "unsupported" === input.sharing || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.sharing || "action-required" === input.sharing || "approval-required" === input.sharing || "available" === input.sharing || "configuration-required" === input.sharing || "disabled" === input.sharing || "temporarily-unavailable" === input.sharing || "unsupported" === input.sharing || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".sharing",
     expected: _ae0,
     value: input.sharing
-  }, _errorFactory)) && (void 0 === input.inboundShare || "action-required" === input.inboundShare || "approval-required" === input.inboundShare || "available" === input.inboundShare || "configuration-required" === input.inboundShare || "disabled" === input.inboundShare || "temporarily-unavailable" === input.inboundShare || "unsupported" === input.inboundShare || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.inboundShare || "action-required" === input.inboundShare || "approval-required" === input.inboundShare || "available" === input.inboundShare || "configuration-required" === input.inboundShare || "disabled" === input.inboundShare || "temporarily-unavailable" === input.inboundShare || "unsupported" === input.inboundShare || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".inboundShare",
     expected: _ae0,
     value: input.inboundShare
-  }, _errorFactory)) && (void 0 === input.notifications || "action-required" === input.notifications || "approval-required" === input.notifications || "available" === input.notifications || "configuration-required" === input.notifications || "disabled" === input.notifications || "temporarily-unavailable" === input.notifications || "unsupported" === input.notifications || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.notifications || "action-required" === input.notifications || "approval-required" === input.notifications || "available" === input.notifications || "configuration-required" === input.notifications || "disabled" === input.notifications || "temporarily-unavailable" === input.notifications || "unsupported" === input.notifications || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".notifications",
     expected: _ae0,
     value: input.notifications
-  }, _errorFactory)) && (void 0 === input.reviews || "action-required" === input.reviews || "approval-required" === input.reviews || "available" === input.reviews || "configuration-required" === input.reviews || "disabled" === input.reviews || "temporarily-unavailable" === input.reviews || "unsupported" === input.reviews || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.reviews || "action-required" === input.reviews || "approval-required" === input.reviews || "available" === input.reviews || "configuration-required" === input.reviews || "disabled" === input.reviews || "temporarily-unavailable" === input.reviews || "unsupported" === input.reviews || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".reviews",
     expected: _ae0,
     value: input.reviews
-  }, _errorFactory)) && (void 0 === input.presentationMode || "fullscreen" === input.presentationMode || "inline-expanded" === input.presentationMode || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.presentationMode || "fullscreen" === input.presentationMode || "inline-expanded" === input.presentationMode || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".presentationMode",
     expected: '("fullscreen" | "inline-expanded" | undefined)',
     value: input.presentationMode
   }, _errorFactory));
-  const _ao7 = (input, _path, _exceptionable = true) => (void 0 === input.profile || "string" === typeof input.profile || _assertGuard_16._assertGuard(_exceptionable, {
+  const _ao7 = (input, _path, _exceptionable = true) => (void 0 === input.profile || "string" === typeof input.profile || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".profile",
     expected: "(string | undefined)",
     value: input.profile
-  }, _errorFactory)) && (void 0 === input.source || "string" === typeof input.source || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.source || "string" === typeof input.source || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".source",
     expected: "(string | undefined)",
     value: input.source
-  }, _errorFactory)) && (void 0 === input.backgroundColor || "string" === typeof input.backgroundColor || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.backgroundColor || "string" === typeof input.backgroundColor || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".backgroundColor",
     expected: "(string | undefined)",
     value: input.backgroundColor
-  }, _errorFactory)) && (void 0 === input.externalUrl || "string" === typeof input.externalUrl || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.externalUrl || "string" === typeof input.externalUrl || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".externalUrl",
     expected: "(string | undefined)",
     value: input.externalUrl
-  }, _errorFactory)) && (void 0 === input.variants || ("object" === typeof input.variants && null !== input.variants && false === Array.isArray(input.variants) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.variants || ("object" === typeof input.variants && null !== input.variants && false === Array.isArray(input.variants) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".variants",
     expected: _ae1,
     value: input.variants
-  }, _errorFactory)) && _ao8(input.variants, _path + ".variants", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao8(input.variants, _path + ".variants", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".variants",
     expected: _ae1,
     value: input.variants
   }, _errorFactory));
-  const _ao8 = (input, _path, _exceptionable = true) => (void 0 === input.maskable || "string" === typeof input.maskable || _assertGuard_16._assertGuard(_exceptionable, {
+  const _ao8 = (input, _path, _exceptionable = true) => (void 0 === input.maskable || "string" === typeof input.maskable || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".maskable",
     expected: "(string | undefined)",
     value: input.maskable
-  }, _errorFactory)) && (void 0 === input.androidForeground || "string" === typeof input.androidForeground || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.androidForeground || "string" === typeof input.androidForeground || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".androidForeground",
     expected: "(string | undefined)",
     value: input.androidForeground
-  }, _errorFactory)) && (void 0 === input.monochrome || "string" === typeof input.monochrome || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.monochrome || "string" === typeof input.monochrome || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".monochrome",
     expected: "(string | undefined)",
     value: input.monochrome
-  }, _errorFactory)) && (void 0 === input.background || "string" === typeof input.background || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.background || "string" === typeof input.background || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".background",
     expected: "(string | undefined)",
     value: input.background
   }, _errorFactory));
-  const _ao9 = (input, _path, _exceptionable = true) => (void 0 === input.withBackButton || "boolean" === typeof input.withBackButton || _assertGuard_16._assertGuard(_exceptionable, {
+  const _ao9 = (input, _path, _exceptionable = true) => (void 0 === input.withBackButton || "boolean" === typeof input.withBackButton || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".withBackButton",
     expected: "(boolean | undefined)",
     value: input.withBackButton
-  }, _errorFactory)) && (void 0 === input.withHomeButton || "boolean" === typeof input.withHomeButton || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.withHomeButton || "boolean" === typeof input.withHomeButton || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".withHomeButton",
     expected: "(boolean | undefined)",
     value: input.withHomeButton
-  }, _errorFactory)) && (void 0 === input.withTitle || "boolean" === typeof input.withTitle || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.withTitle || "boolean" === typeof input.withTitle || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".withTitle",
     expected: "(boolean | undefined)",
     value: input.withTitle
-  }, _errorFactory)) && (void 0 === input.transparentBackground || "boolean" === typeof input.transparentBackground || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.transparentBackground || "boolean" === typeof input.transparentBackground || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".transparentBackground",
     expected: "(boolean | undefined)",
     value: input.transparentBackground
-  }, _errorFactory)) && (void 0 === input.theme || "dark" === input.theme || "light" === input.theme || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.theme || "dark" === input.theme || "light" === input.theme || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".theme",
     expected: '("dark" | "light" | undefined)',
@@ -9777,7 +9782,7 @@ var assertPlatformTargetsConfig = /* @__PURE__ */ (() => {
     else if ("web" === input.kind)
       return _ao15(input, _path, _exceptionable);
     else
-      return _assertGuard_16._assertGuard(_exceptionable, {
+      return _assertGuard_17._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path,
         expected: "(AppsInTossTargetConfig | CapacitorTargetConfig | DevvitTargetConfig | MiniGameTargetConfig | WebTargetConfig)",
@@ -9829,12 +9834,12 @@ var assertPlatformTargetsConfig = /* @__PURE__ */ (() => {
   return (input, errorFactory) => {
     if (false === __is(input)) {
       _errorFactory = errorFactory;
-      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_16._assertGuard(true, {
+      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_17._assertGuard(true, {
         method: "typia.createAssert",
         path: _path + "",
         expected: "PlatformTargetsConfig",
         value: input2
-      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_16._assertGuard(true, {
+      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_17._assertGuard(true, {
         method: "typia.createAssert",
         path: _path + "",
         expected: "PlatformTargetsConfig",
@@ -10133,12 +10138,12 @@ function assertTargetKind(input, target2) {
 }
 
 // node_modules/.cache/mpgd-native-build/tools/target/target-config-matrix.js
-import * as _assertGuard_17 from "typia/lib/internal/_assertGuard";
-import * as _accessExpressionAsString_18 from "typia/lib/internal/_accessExpressionAsString";
+import * as _assertGuard_18 from "typia/lib/internal/_assertGuard";
+import * as _accessExpressionAsString_19 from "typia/lib/internal/_accessExpressionAsString";
 import { createHash as createHash6 } from "node:crypto";
 import { readFileSync as readFileSync11 } from "node:fs";
-import typia9 from "typia";
-var __typia_transform__accessExpressionAsString4 = _accessExpressionAsString_18._accessExpressionAsString;
+import typia10 from "typia";
+var __typia_transform__accessExpressionAsString4 = _accessExpressionAsString_19._accessExpressionAsString;
 var defaultTargetConfigMatrixFile = "packages/target-config/targets.json";
 var assertTargetConfigMatrix = /* @__PURE__ */ (() => {
   const _iv0 = /* @__PURE__ */ new Set(["apps-in-toss", "capacitor-android", "capacitor-ios", "crazygames-web", "devvit-web", "microsoft-store-pwa", "oneplay-web", "tiktok-minigame", "verse8-web", "web", "web-preview", "wechat-minigame"]);
@@ -10150,31 +10155,31 @@ var assertTargetConfigMatrix = /* @__PURE__ */ (() => {
   const _iv1 = /* @__PURE__ */ new Set(["app-store", "apps-in-toss", "crazygames", "devvit", "google-play", "microsoft-store", "oneplay", "tiktok-minigame", "verse8", "web", "web-preview", "wechat-minigame"]);
   const _av0 = /* @__PURE__ */ new Set(["apps-in-toss", "capacitor-android", "capacitor-ios", "crazygames-web", "devvit-web", "microsoft-store-pwa", "oneplay-web", "tiktok-minigame", "verse8-web", "web", "web-preview", "wechat-minigame"]);
   const _ae0 = '("apps-in-toss" | "capacitor-android" | "capacitor-ios" | "crazygames-web" | "devvit-web" | "microsoft-store-pwa" | "oneplay-web" | "tiktok-minigame" | "verse8-web" | "web" | "web-preview" | "wechat-minigame")';
-  const _ap0 = (input, _path, _exceptionable = true) => "boolean" === typeof input["iap"] || _assertGuard_17._assertGuard(_exceptionable, {
+  const _ap0 = (input, _path, _exceptionable = true) => "boolean" === typeof input["iap"] || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".iap",
     expected: "boolean",
     value: input["iap"]
   }, _errorFactory);
-  const _ap1 = (input, _path, _exceptionable = true) => void 0 === input["bannerAds"] || "boolean" === typeof input["bannerAds"] || _assertGuard_17._assertGuard(_exceptionable, {
+  const _ap1 = (input, _path, _exceptionable = true) => void 0 === input["bannerAds"] || "boolean" === typeof input["bannerAds"] || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".bannerAds",
     expected: "(boolean | undefined)",
     value: input["bannerAds"]
   }, _errorFactory);
-  const _ap2 = (input, _path, _exceptionable = true) => "boolean" === typeof input["rewardedAds"] || _assertGuard_17._assertGuard(_exceptionable, {
+  const _ap2 = (input, _path, _exceptionable = true) => "boolean" === typeof input["rewardedAds"] || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".rewardedAds",
     expected: "boolean",
     value: input["rewardedAds"]
   }, _errorFactory);
-  const _ap3 = (input, _path, _exceptionable = true) => "boolean" === typeof input["interstitialAds"] || _assertGuard_17._assertGuard(_exceptionable, {
+  const _ap3 = (input, _path, _exceptionable = true) => "boolean" === typeof input["interstitialAds"] || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".interstitialAds",
     expected: "boolean",
     value: input["interstitialAds"]
   }, _errorFactory);
-  const _ap4 = (input, _path, _exceptionable = true) => "boolean" === typeof input["localization"] || _assertGuard_17._assertGuard(_exceptionable, {
+  const _ap4 = (input, _path, _exceptionable = true) => "boolean" === typeof input["localization"] || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".localization",
     expected: "boolean",
@@ -10184,17 +10189,17 @@ var assertTargetConfigMatrix = /* @__PURE__ */ (() => {
   const _ae1 = '("app-store" | "apps-in-toss" | "crazygames" | "devvit" | "google-play" | "microsoft-store" | "oneplay" | "tiktok-minigame" | "verse8" | "web" | "web-preview" | "wechat-minigame")';
   const _ae2 = '("action-required" | "approval-required" | "available" | "configuration-required" | "disabled" | "temporarily-unavailable" | "unsupported")';
   const _ae3 = '("action-required" | "approval-required" | "available" | "configuration-required" | "disabled" | "temporarily-unavailable" | "unsupported" | undefined)';
-  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.version || _assertGuard_17._assertGuard(_exceptionable, {
+  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.version || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".version",
     expected: "string",
     value: input.version
-  }, _errorFactory)) && (("object" === typeof input.targets && null !== input.targets && false === Array.isArray(input.targets) || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.targets && null !== input.targets && false === Array.isArray(input.targets) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".targets",
     expected: "Record<string, TargetConfig>",
     value: input.targets
-  }, _errorFactory)) && _ao1(input.targets, _path + ".targets", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao1(input.targets, _path + ".targets", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".targets",
     expected: "Record<string, TargetConfig>",
@@ -10204,212 +10209,212 @@ var assertTargetConfigMatrix = /* @__PURE__ */ (() => {
     const value = input[key];
     if (void 0 === value)
       return true;
-    return ("object" === typeof value && null !== value || _assertGuard_17._assertGuard(_exceptionable, {
+    return ("object" === typeof value && null !== value || _assertGuard_18._assertGuard(_exceptionable, {
       method: "typia.createAssert",
       path: _path + __typia_transform__accessExpressionAsString4(key),
       expected: "TargetConfig",
       value
-    }, _errorFactory)) && _ao2(value, _path + __typia_transform__accessExpressionAsString4(key), _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
+    }, _errorFactory)) && _ao2(value, _path + __typia_transform__accessExpressionAsString4(key), _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
       method: "typia.createAssert",
       path: _path + __typia_transform__accessExpressionAsString4(key),
       expected: "TargetConfig",
       value
     }, _errorFactory);
   });
-  const _ao10 = (input, _path, _exceptionable = true) => ("action-required" === input.identityUpgrade || "approval-required" === input.identityUpgrade || "available" === input.identityUpgrade || "configuration-required" === input.identityUpgrade || "disabled" === input.identityUpgrade || "temporarily-unavailable" === input.identityUpgrade || "unsupported" === input.identityUpgrade || _assertGuard_17._assertGuard(_exceptionable, {
+  const _ao10 = (input, _path, _exceptionable = true) => ("action-required" === input.identityUpgrade || "approval-required" === input.identityUpgrade || "available" === input.identityUpgrade || "configuration-required" === input.identityUpgrade || "disabled" === input.identityUpgrade || "temporarily-unavailable" === input.identityUpgrade || "unsupported" === input.identityUpgrade || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".identityUpgrade",
     expected: _ae2,
     value: input.identityUpgrade
-  }, _errorFactory)) && ("action-required" === input.presentation || "approval-required" === input.presentation || "available" === input.presentation || "configuration-required" === input.presentation || "disabled" === input.presentation || "temporarily-unavailable" === input.presentation || "unsupported" === input.presentation || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("action-required" === input.presentation || "approval-required" === input.presentation || "available" === input.presentation || "configuration-required" === input.presentation || "disabled" === input.presentation || "temporarily-unavailable" === input.presentation || "unsupported" === input.presentation || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".presentation",
     expected: _ae2,
     value: input.presentation
-  }, _errorFactory)) && ("action-required" === input.sharing || "approval-required" === input.sharing || "available" === input.sharing || "configuration-required" === input.sharing || "disabled" === input.sharing || "temporarily-unavailable" === input.sharing || "unsupported" === input.sharing || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("action-required" === input.sharing || "approval-required" === input.sharing || "available" === input.sharing || "configuration-required" === input.sharing || "disabled" === input.sharing || "temporarily-unavailable" === input.sharing || "unsupported" === input.sharing || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".sharing",
     expected: _ae2,
     value: input.sharing
-  }, _errorFactory)) && ("action-required" === input.inboundShare || "approval-required" === input.inboundShare || "available" === input.inboundShare || "configuration-required" === input.inboundShare || "disabled" === input.inboundShare || "temporarily-unavailable" === input.inboundShare || "unsupported" === input.inboundShare || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("action-required" === input.inboundShare || "approval-required" === input.inboundShare || "available" === input.inboundShare || "configuration-required" === input.inboundShare || "disabled" === input.inboundShare || "temporarily-unavailable" === input.inboundShare || "unsupported" === input.inboundShare || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".inboundShare",
     expected: _ae2,
     value: input.inboundShare
-  }, _errorFactory)) && ("action-required" === input.notifications || "approval-required" === input.notifications || "available" === input.notifications || "configuration-required" === input.notifications || "disabled" === input.notifications || "temporarily-unavailable" === input.notifications || "unsupported" === input.notifications || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("action-required" === input.notifications || "approval-required" === input.notifications || "available" === input.notifications || "configuration-required" === input.notifications || "disabled" === input.notifications || "temporarily-unavailable" === input.notifications || "unsupported" === input.notifications || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".notifications",
     expected: _ae2,
     value: input.notifications
-  }, _errorFactory)) && (void 0 === input.reviews || "action-required" === input.reviews || "approval-required" === input.reviews || "available" === input.reviews || "configuration-required" === input.reviews || "disabled" === input.reviews || "temporarily-unavailable" === input.reviews || "unsupported" === input.reviews || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.reviews || "action-required" === input.reviews || "approval-required" === input.reviews || "available" === input.reviews || "configuration-required" === input.reviews || "disabled" === input.reviews || "temporarily-unavailable" === input.reviews || "unsupported" === input.reviews || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".reviews",
     expected: _ae3,
     value: input.reviews
-  }, _errorFactory)) && ("fullscreen" === input.presentationMode || "inline-expanded" === input.presentationMode || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("fullscreen" === input.presentationMode || "inline-expanded" === input.presentationMode || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".presentationMode",
     expected: '("fullscreen" | "inline-expanded")',
     value: input.presentationMode
   }, _errorFactory));
-  const _ao2 = (input, _path, _exceptionable = true) => (true === _av0.has(input.runtime) || _assertGuard_17._assertGuard(_exceptionable, {
+  const _ao2 = (input, _path, _exceptionable = true) => (true === _av0.has(input.runtime) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".runtime",
     expected: _ae0,
     value: input.runtime
-  }, _errorFactory)) && (("object" === typeof input.features && null !== input.features || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.features && null !== input.features || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".features",
     expected: "TargetFeatureConfig",
     value: input.features
-  }, _errorFactory)) && _ao3(input.features, _path + ".features", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao3(input.features, _path + ".features", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".features",
     expected: "TargetFeatureConfig",
     value: input.features
-  }, _errorFactory)) && (("object" === typeof input.capabilities && null !== input.capabilities || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.capabilities && null !== input.capabilities || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".capabilities",
     expected: "TargetCapabilityConfig",
     value: input.capabilities
-  }, _errorFactory)) && _ao4(input.capabilities, _path + ".capabilities", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao4(input.capabilities, _path + ".capabilities", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".capabilities",
     expected: "TargetCapabilityConfig",
     value: input.capabilities
-  }, _errorFactory)) && (("object" === typeof input.localization && null !== input.localization || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.localization && null !== input.localization || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".localization",
     expected: "TargetLocalizationConfig",
     value: input.localization
-  }, _errorFactory)) && _ao5(input.localization, _path + ".localization", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao5(input.localization, _path + ".localization", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".localization",
     expected: "TargetLocalizationConfig",
     value: input.localization
-  }, _errorFactory)) && (("object" === typeof input.monetization && null !== input.monetization || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.monetization && null !== input.monetization || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".monetization",
     expected: "TargetMonetizationConfig",
     value: input.monetization
-  }, _errorFactory)) && _ao6(input.monetization, _path + ".monetization", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao6(input.monetization, _path + ".monetization", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".monetization",
     expected: "TargetMonetizationConfig",
     value: input.monetization
-  }, _errorFactory)) && (("object" === typeof input.leaderboard && null !== input.leaderboard || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.leaderboard && null !== input.leaderboard || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".leaderboard",
     expected: "TargetLeaderboardConfig",
     value: input.leaderboard
-  }, _errorFactory)) && _ao7(input.leaderboard, _path + ".leaderboard", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao7(input.leaderboard, _path + ".leaderboard", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".leaderboard",
     expected: "TargetLeaderboardConfig",
     value: input.leaderboard
-  }, _errorFactory)) && (("object" === typeof input.release && null !== input.release || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.release && null !== input.release || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".release",
     expected: "TargetReleaseConfig",
     value: input.release
-  }, _errorFactory)) && _ao8(input.release, _path + ".release", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao8(input.release, _path + ".release", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".release",
     expected: "TargetReleaseConfig",
     value: input.release
-  }, _errorFactory)) && (("object" === typeof input.policy && null !== input.policy || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.policy && null !== input.policy || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".policy",
     expected: "TargetPolicyRestrictions",
     value: input.policy
-  }, _errorFactory)) && _ao9(input.policy, _path + ".policy", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao9(input.policy, _path + ".policy", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".policy",
     expected: "TargetPolicyRestrictions",
     value: input.policy
-  }, _errorFactory)) && (void 0 === input.integrations || ("object" === typeof input.integrations && null !== input.integrations || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.integrations || ("object" === typeof input.integrations && null !== input.integrations || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".integrations",
     expected: "(TargetIntegrationConfig | undefined)",
     value: input.integrations
-  }, _errorFactory)) && _ao10(input.integrations, _path + ".integrations", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao10(input.integrations, _path + ".integrations", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".integrations",
     expected: "(TargetIntegrationConfig | undefined)",
     value: input.integrations
   }, _errorFactory));
-  const _ao3 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && (void 0 === input.subscriptions || "boolean" === typeof input.subscriptions || _assertGuard_17._assertGuard(_exceptionable, {
+  const _ao3 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && (void 0 === input.subscriptions || "boolean" === typeof input.subscriptions || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".subscriptions",
     expected: "(boolean | undefined)",
     value: input.subscriptions
-  }, _errorFactory)) && _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && _ap3(input, _path, _exceptionable) && ("boolean" === typeof input.leaderboard || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && _ap3(input, _path, _exceptionable) && ("boolean" === typeof input.leaderboard || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".leaderboard",
     expected: "boolean",
     value: input.leaderboard
-  }, _errorFactory)) && (void 0 === input.nativeLeaderboard || "boolean" === typeof input.nativeLeaderboard || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.nativeLeaderboard || "boolean" === typeof input.nativeLeaderboard || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".nativeLeaderboard",
     expected: "(boolean | undefined)",
     value: input.nativeLeaderboard
-  }, _errorFactory)) && (void 0 === input.remoteLeaderboard || "boolean" === typeof input.remoteLeaderboard || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.remoteLeaderboard || "boolean" === typeof input.remoteLeaderboard || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".remoteLeaderboard",
     expected: "(boolean | undefined)",
     value: input.remoteLeaderboard
   }, _errorFactory)) && _ap4(input, _path, _exceptionable);
-  const _ao4 = (input, _path, _exceptionable = true) => ("local" === input.storage || "native" === input.storage || "none" === input.storage || _assertGuard_17._assertGuard(_exceptionable, {
+  const _ao4 = (input, _path, _exceptionable = true) => ("local" === input.storage || "native" === input.storage || "none" === input.storage || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".storage",
     expected: '("local" | "native" | "none")',
     value: input.storage
   }, _errorFactory)) && _ap4(input, _path, _exceptionable);
-  const _ao5 = (input, _path, _exceptionable = true) => "en" === input.fallbackLocale || "ko" === input.fallbackLocale || _assertGuard_17._assertGuard(_exceptionable, {
+  const _ao5 = (input, _path, _exceptionable = true) => "en" === input.fallbackLocale || "ko" === input.fallbackLocale || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".fallbackLocale",
     expected: '("en" | "ko")',
     value: input.fallbackLocale
   }, _errorFactory);
   const _ao6 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && _ap3(input, _path, _exceptionable);
-  const _ao7 = (input, _path, _exceptionable = true) => "boolean" === typeof input.native || _assertGuard_17._assertGuard(_exceptionable, {
+  const _ao7 = (input, _path, _exceptionable = true) => "boolean" === typeof input.native || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".native",
     expected: "boolean",
     value: input.native
   }, _errorFactory);
-  const _ao8 = (input, _path, _exceptionable = true) => (true === _av1.has(input.profile) || _assertGuard_17._assertGuard(_exceptionable, {
+  const _ao8 = (input, _path, _exceptionable = true) => (true === _av1.has(input.profile) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".profile",
     expected: _ae1,
     value: input.profile
-  }, _errorFactory)) && (void 0 === input.billingAuthority || "host" === input.billingAuthority || "store" === input.billingAuthority || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.billingAuthority || "host" === input.billingAuthority || "store" === input.billingAuthority || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".billingAuthority",
     expected: '("host" | "store" | undefined)',
     value: input.billingAuthority
   }, _errorFactory));
-  const _ao9 = (input, _path, _exceptionable = true) => ("boolean" === typeof input.externalPaymentAllowed || _assertGuard_17._assertGuard(_exceptionable, {
+  const _ao9 = (input, _path, _exceptionable = true) => ("boolean" === typeof input.externalPaymentAllowed || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".externalPaymentAllowed",
     expected: "boolean",
     value: input.externalPaymentAllowed
-  }, _errorFactory)) && ("boolean" === typeof input.remoteExecutableCodeAllowed || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("boolean" === typeof input.remoteExecutableCodeAllowed || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".remoteExecutableCodeAllowed",
     expected: "boolean",
     value: input.remoteExecutableCodeAllowed
-  }, _errorFactory)) && ("boolean" === typeof input.installOtherAppCTAAllowed || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("boolean" === typeof input.installOtherAppCTAAllowed || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".installOtherAppCTAAllowed",
     expected: "boolean",
     value: input.installOtherAppCTAAllowed
-  }, _errorFactory)) && ("boolean" === typeof input.requiresStoreReview || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("boolean" === typeof input.requiresStoreReview || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".requiresStoreReview",
     expected: "boolean",
     value: input.requiresStoreReview
-  }, _errorFactory)) && ("boolean" === typeof input.requiresAitReview || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("boolean" === typeof input.requiresAitReview || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".requiresAitReview",
     expected: "boolean",
@@ -10436,12 +10441,12 @@ var assertTargetConfigMatrix = /* @__PURE__ */ (() => {
   return (input, errorFactory) => {
     if (false === __is(input)) {
       _errorFactory = errorFactory;
-      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_17._assertGuard(true, {
+      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_18._assertGuard(true, {
         method: "typia.createAssert",
         path: _path + "",
         expected: "TargetConfigMatrix",
         value: input2
-      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_17._assertGuard(true, {
+      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_18._assertGuard(true, {
         method: "typia.createAssert",
         path: _path + "",
         expected: "TargetConfigMatrix",
@@ -10461,31 +10466,31 @@ var assertTargetConfigExtensions = /* @__PURE__ */ (() => {
   const _iv1 = /* @__PURE__ */ new Set(["app-store", "apps-in-toss", "crazygames", "devvit", "google-play", "microsoft-store", "oneplay", "tiktok-minigame", "verse8", "web", "web-preview", "wechat-minigame"]);
   const _av0 = /* @__PURE__ */ new Set(["apps-in-toss", "capacitor-android", "capacitor-ios", "crazygames-web", "devvit-web", "microsoft-store-pwa", "oneplay-web", "tiktok-minigame", "verse8-web", "web", "web-preview", "wechat-minigame"]);
   const _ae0 = '("apps-in-toss" | "capacitor-android" | "capacitor-ios" | "crazygames-web" | "devvit-web" | "microsoft-store-pwa" | "oneplay-web" | "tiktok-minigame" | "verse8-web" | "web" | "web-preview" | "wechat-minigame")';
-  const _ap0 = (input, _path, _exceptionable = true) => "boolean" === typeof input["iap"] || _assertGuard_17._assertGuard(_exceptionable, {
+  const _ap0 = (input, _path, _exceptionable = true) => "boolean" === typeof input["iap"] || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".iap",
     expected: "boolean",
     value: input["iap"]
   }, _errorFactory);
-  const _ap1 = (input, _path, _exceptionable = true) => void 0 === input["bannerAds"] || "boolean" === typeof input["bannerAds"] || _assertGuard_17._assertGuard(_exceptionable, {
+  const _ap1 = (input, _path, _exceptionable = true) => void 0 === input["bannerAds"] || "boolean" === typeof input["bannerAds"] || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".bannerAds",
     expected: "(boolean | undefined)",
     value: input["bannerAds"]
   }, _errorFactory);
-  const _ap2 = (input, _path, _exceptionable = true) => "boolean" === typeof input["rewardedAds"] || _assertGuard_17._assertGuard(_exceptionable, {
+  const _ap2 = (input, _path, _exceptionable = true) => "boolean" === typeof input["rewardedAds"] || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".rewardedAds",
     expected: "boolean",
     value: input["rewardedAds"]
   }, _errorFactory);
-  const _ap3 = (input, _path, _exceptionable = true) => "boolean" === typeof input["interstitialAds"] || _assertGuard_17._assertGuard(_exceptionable, {
+  const _ap3 = (input, _path, _exceptionable = true) => "boolean" === typeof input["interstitialAds"] || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".interstitialAds",
     expected: "boolean",
     value: input["interstitialAds"]
   }, _errorFactory);
-  const _ap4 = (input, _path, _exceptionable = true) => "boolean" === typeof input["localization"] || _assertGuard_17._assertGuard(_exceptionable, {
+  const _ap4 = (input, _path, _exceptionable = true) => "boolean" === typeof input["localization"] || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".localization",
     expected: "boolean",
@@ -10495,17 +10500,17 @@ var assertTargetConfigExtensions = /* @__PURE__ */ (() => {
   const _ae1 = '("app-store" | "apps-in-toss" | "crazygames" | "devvit" | "google-play" | "microsoft-store" | "oneplay" | "tiktok-minigame" | "verse8" | "web" | "web-preview" | "wechat-minigame")';
   const _ae2 = '("action-required" | "approval-required" | "available" | "configuration-required" | "disabled" | "temporarily-unavailable" | "unsupported")';
   const _ae3 = '("action-required" | "approval-required" | "available" | "configuration-required" | "disabled" | "temporarily-unavailable" | "unsupported" | undefined)';
-  const _ao0 = (input, _path, _exceptionable = true) => (1 === input.schemaVersion || _assertGuard_17._assertGuard(_exceptionable, {
+  const _ao0 = (input, _path, _exceptionable = true) => (1 === input.schemaVersion || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".schemaVersion",
     expected: "1",
     value: input.schemaVersion
-  }, _errorFactory)) && (("object" === typeof input.targets && null !== input.targets && false === Array.isArray(input.targets) || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.targets && null !== input.targets && false === Array.isArray(input.targets) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".targets",
     expected: "Readonly<Record<string, TargetConfig>>",
     value: input.targets
-  }, _errorFactory)) && _ao1(input.targets, _path + ".targets", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao1(input.targets, _path + ".targets", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".targets",
     expected: "Readonly<Record<string, TargetConfig>>",
@@ -10515,212 +10520,212 @@ var assertTargetConfigExtensions = /* @__PURE__ */ (() => {
     const value = input[key];
     if (void 0 === value)
       return true;
-    return ("object" === typeof value && null !== value || _assertGuard_17._assertGuard(_exceptionable, {
+    return ("object" === typeof value && null !== value || _assertGuard_18._assertGuard(_exceptionable, {
       method: "typia.createAssert",
       path: _path + __typia_transform__accessExpressionAsString4(key),
       expected: "TargetConfig",
       value
-    }, _errorFactory)) && _ao2(value, _path + __typia_transform__accessExpressionAsString4(key), _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
+    }, _errorFactory)) && _ao2(value, _path + __typia_transform__accessExpressionAsString4(key), _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
       method: "typia.createAssert",
       path: _path + __typia_transform__accessExpressionAsString4(key),
       expected: "TargetConfig",
       value
     }, _errorFactory);
   });
-  const _ao10 = (input, _path, _exceptionable = true) => ("action-required" === input.identityUpgrade || "approval-required" === input.identityUpgrade || "available" === input.identityUpgrade || "configuration-required" === input.identityUpgrade || "disabled" === input.identityUpgrade || "temporarily-unavailable" === input.identityUpgrade || "unsupported" === input.identityUpgrade || _assertGuard_17._assertGuard(_exceptionable, {
+  const _ao10 = (input, _path, _exceptionable = true) => ("action-required" === input.identityUpgrade || "approval-required" === input.identityUpgrade || "available" === input.identityUpgrade || "configuration-required" === input.identityUpgrade || "disabled" === input.identityUpgrade || "temporarily-unavailable" === input.identityUpgrade || "unsupported" === input.identityUpgrade || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".identityUpgrade",
     expected: _ae2,
     value: input.identityUpgrade
-  }, _errorFactory)) && ("action-required" === input.presentation || "approval-required" === input.presentation || "available" === input.presentation || "configuration-required" === input.presentation || "disabled" === input.presentation || "temporarily-unavailable" === input.presentation || "unsupported" === input.presentation || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("action-required" === input.presentation || "approval-required" === input.presentation || "available" === input.presentation || "configuration-required" === input.presentation || "disabled" === input.presentation || "temporarily-unavailable" === input.presentation || "unsupported" === input.presentation || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".presentation",
     expected: _ae2,
     value: input.presentation
-  }, _errorFactory)) && ("action-required" === input.sharing || "approval-required" === input.sharing || "available" === input.sharing || "configuration-required" === input.sharing || "disabled" === input.sharing || "temporarily-unavailable" === input.sharing || "unsupported" === input.sharing || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("action-required" === input.sharing || "approval-required" === input.sharing || "available" === input.sharing || "configuration-required" === input.sharing || "disabled" === input.sharing || "temporarily-unavailable" === input.sharing || "unsupported" === input.sharing || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".sharing",
     expected: _ae2,
     value: input.sharing
-  }, _errorFactory)) && ("action-required" === input.inboundShare || "approval-required" === input.inboundShare || "available" === input.inboundShare || "configuration-required" === input.inboundShare || "disabled" === input.inboundShare || "temporarily-unavailable" === input.inboundShare || "unsupported" === input.inboundShare || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("action-required" === input.inboundShare || "approval-required" === input.inboundShare || "available" === input.inboundShare || "configuration-required" === input.inboundShare || "disabled" === input.inboundShare || "temporarily-unavailable" === input.inboundShare || "unsupported" === input.inboundShare || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".inboundShare",
     expected: _ae2,
     value: input.inboundShare
-  }, _errorFactory)) && ("action-required" === input.notifications || "approval-required" === input.notifications || "available" === input.notifications || "configuration-required" === input.notifications || "disabled" === input.notifications || "temporarily-unavailable" === input.notifications || "unsupported" === input.notifications || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("action-required" === input.notifications || "approval-required" === input.notifications || "available" === input.notifications || "configuration-required" === input.notifications || "disabled" === input.notifications || "temporarily-unavailable" === input.notifications || "unsupported" === input.notifications || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".notifications",
     expected: _ae2,
     value: input.notifications
-  }, _errorFactory)) && (void 0 === input.reviews || "action-required" === input.reviews || "approval-required" === input.reviews || "available" === input.reviews || "configuration-required" === input.reviews || "disabled" === input.reviews || "temporarily-unavailable" === input.reviews || "unsupported" === input.reviews || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.reviews || "action-required" === input.reviews || "approval-required" === input.reviews || "available" === input.reviews || "configuration-required" === input.reviews || "disabled" === input.reviews || "temporarily-unavailable" === input.reviews || "unsupported" === input.reviews || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".reviews",
     expected: _ae3,
     value: input.reviews
-  }, _errorFactory)) && ("fullscreen" === input.presentationMode || "inline-expanded" === input.presentationMode || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("fullscreen" === input.presentationMode || "inline-expanded" === input.presentationMode || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".presentationMode",
     expected: '("fullscreen" | "inline-expanded")',
     value: input.presentationMode
   }, _errorFactory));
-  const _ao2 = (input, _path, _exceptionable = true) => (true === _av0.has(input.runtime) || _assertGuard_17._assertGuard(_exceptionable, {
+  const _ao2 = (input, _path, _exceptionable = true) => (true === _av0.has(input.runtime) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".runtime",
     expected: _ae0,
     value: input.runtime
-  }, _errorFactory)) && (("object" === typeof input.features && null !== input.features || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.features && null !== input.features || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".features",
     expected: "TargetFeatureConfig",
     value: input.features
-  }, _errorFactory)) && _ao3(input.features, _path + ".features", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao3(input.features, _path + ".features", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".features",
     expected: "TargetFeatureConfig",
     value: input.features
-  }, _errorFactory)) && (("object" === typeof input.capabilities && null !== input.capabilities || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.capabilities && null !== input.capabilities || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".capabilities",
     expected: "TargetCapabilityConfig",
     value: input.capabilities
-  }, _errorFactory)) && _ao4(input.capabilities, _path + ".capabilities", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao4(input.capabilities, _path + ".capabilities", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".capabilities",
     expected: "TargetCapabilityConfig",
     value: input.capabilities
-  }, _errorFactory)) && (("object" === typeof input.localization && null !== input.localization || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.localization && null !== input.localization || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".localization",
     expected: "TargetLocalizationConfig",
     value: input.localization
-  }, _errorFactory)) && _ao5(input.localization, _path + ".localization", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao5(input.localization, _path + ".localization", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".localization",
     expected: "TargetLocalizationConfig",
     value: input.localization
-  }, _errorFactory)) && (("object" === typeof input.monetization && null !== input.monetization || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.monetization && null !== input.monetization || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".monetization",
     expected: "TargetMonetizationConfig",
     value: input.monetization
-  }, _errorFactory)) && _ao6(input.monetization, _path + ".monetization", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao6(input.monetization, _path + ".monetization", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".monetization",
     expected: "TargetMonetizationConfig",
     value: input.monetization
-  }, _errorFactory)) && (("object" === typeof input.leaderboard && null !== input.leaderboard || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.leaderboard && null !== input.leaderboard || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".leaderboard",
     expected: "TargetLeaderboardConfig",
     value: input.leaderboard
-  }, _errorFactory)) && _ao7(input.leaderboard, _path + ".leaderboard", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao7(input.leaderboard, _path + ".leaderboard", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".leaderboard",
     expected: "TargetLeaderboardConfig",
     value: input.leaderboard
-  }, _errorFactory)) && (("object" === typeof input.release && null !== input.release || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.release && null !== input.release || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".release",
     expected: "TargetReleaseConfig",
     value: input.release
-  }, _errorFactory)) && _ao8(input.release, _path + ".release", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao8(input.release, _path + ".release", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".release",
     expected: "TargetReleaseConfig",
     value: input.release
-  }, _errorFactory)) && (("object" === typeof input.policy && null !== input.policy || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.policy && null !== input.policy || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".policy",
     expected: "TargetPolicyRestrictions",
     value: input.policy
-  }, _errorFactory)) && _ao9(input.policy, _path + ".policy", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao9(input.policy, _path + ".policy", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".policy",
     expected: "TargetPolicyRestrictions",
     value: input.policy
-  }, _errorFactory)) && (void 0 === input.integrations || ("object" === typeof input.integrations && null !== input.integrations || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.integrations || ("object" === typeof input.integrations && null !== input.integrations || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".integrations",
     expected: "(TargetIntegrationConfig | undefined)",
     value: input.integrations
-  }, _errorFactory)) && _ao10(input.integrations, _path + ".integrations", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao10(input.integrations, _path + ".integrations", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".integrations",
     expected: "(TargetIntegrationConfig | undefined)",
     value: input.integrations
   }, _errorFactory));
-  const _ao3 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && (void 0 === input.subscriptions || "boolean" === typeof input.subscriptions || _assertGuard_17._assertGuard(_exceptionable, {
+  const _ao3 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && (void 0 === input.subscriptions || "boolean" === typeof input.subscriptions || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".subscriptions",
     expected: "(boolean | undefined)",
     value: input.subscriptions
-  }, _errorFactory)) && _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && _ap3(input, _path, _exceptionable) && ("boolean" === typeof input.leaderboard || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && _ap3(input, _path, _exceptionable) && ("boolean" === typeof input.leaderboard || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".leaderboard",
     expected: "boolean",
     value: input.leaderboard
-  }, _errorFactory)) && (void 0 === input.nativeLeaderboard || "boolean" === typeof input.nativeLeaderboard || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.nativeLeaderboard || "boolean" === typeof input.nativeLeaderboard || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".nativeLeaderboard",
     expected: "(boolean | undefined)",
     value: input.nativeLeaderboard
-  }, _errorFactory)) && (void 0 === input.remoteLeaderboard || "boolean" === typeof input.remoteLeaderboard || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.remoteLeaderboard || "boolean" === typeof input.remoteLeaderboard || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".remoteLeaderboard",
     expected: "(boolean | undefined)",
     value: input.remoteLeaderboard
   }, _errorFactory)) && _ap4(input, _path, _exceptionable);
-  const _ao4 = (input, _path, _exceptionable = true) => ("local" === input.storage || "native" === input.storage || "none" === input.storage || _assertGuard_17._assertGuard(_exceptionable, {
+  const _ao4 = (input, _path, _exceptionable = true) => ("local" === input.storage || "native" === input.storage || "none" === input.storage || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".storage",
     expected: '("local" | "native" | "none")',
     value: input.storage
   }, _errorFactory)) && _ap4(input, _path, _exceptionable);
-  const _ao5 = (input, _path, _exceptionable = true) => "en" === input.fallbackLocale || "ko" === input.fallbackLocale || _assertGuard_17._assertGuard(_exceptionable, {
+  const _ao5 = (input, _path, _exceptionable = true) => "en" === input.fallbackLocale || "ko" === input.fallbackLocale || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".fallbackLocale",
     expected: '("en" | "ko")',
     value: input.fallbackLocale
   }, _errorFactory);
   const _ao6 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && _ap3(input, _path, _exceptionable);
-  const _ao7 = (input, _path, _exceptionable = true) => "boolean" === typeof input.native || _assertGuard_17._assertGuard(_exceptionable, {
+  const _ao7 = (input, _path, _exceptionable = true) => "boolean" === typeof input.native || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".native",
     expected: "boolean",
     value: input.native
   }, _errorFactory);
-  const _ao8 = (input, _path, _exceptionable = true) => (true === _av1.has(input.profile) || _assertGuard_17._assertGuard(_exceptionable, {
+  const _ao8 = (input, _path, _exceptionable = true) => (true === _av1.has(input.profile) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".profile",
     expected: _ae1,
     value: input.profile
-  }, _errorFactory)) && (void 0 === input.billingAuthority || "host" === input.billingAuthority || "store" === input.billingAuthority || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.billingAuthority || "host" === input.billingAuthority || "store" === input.billingAuthority || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".billingAuthority",
     expected: '("host" | "store" | undefined)',
     value: input.billingAuthority
   }, _errorFactory));
-  const _ao9 = (input, _path, _exceptionable = true) => ("boolean" === typeof input.externalPaymentAllowed || _assertGuard_17._assertGuard(_exceptionable, {
+  const _ao9 = (input, _path, _exceptionable = true) => ("boolean" === typeof input.externalPaymentAllowed || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".externalPaymentAllowed",
     expected: "boolean",
     value: input.externalPaymentAllowed
-  }, _errorFactory)) && ("boolean" === typeof input.remoteExecutableCodeAllowed || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("boolean" === typeof input.remoteExecutableCodeAllowed || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".remoteExecutableCodeAllowed",
     expected: "boolean",
     value: input.remoteExecutableCodeAllowed
-  }, _errorFactory)) && ("boolean" === typeof input.installOtherAppCTAAllowed || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("boolean" === typeof input.installOtherAppCTAAllowed || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".installOtherAppCTAAllowed",
     expected: "boolean",
     value: input.installOtherAppCTAAllowed
-  }, _errorFactory)) && ("boolean" === typeof input.requiresStoreReview || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("boolean" === typeof input.requiresStoreReview || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".requiresStoreReview",
     expected: "boolean",
     value: input.requiresStoreReview
-  }, _errorFactory)) && ("boolean" === typeof input.requiresAitReview || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("boolean" === typeof input.requiresAitReview || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".requiresAitReview",
     expected: "boolean",
@@ -10747,12 +10752,12 @@ var assertTargetConfigExtensions = /* @__PURE__ */ (() => {
   return (input, errorFactory) => {
     if (false === __is(input)) {
       _errorFactory = errorFactory;
-      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_17._assertGuard(true, {
+      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_18._assertGuard(true, {
         method: "typia.createAssert",
         path: _path + "",
         expected: "TargetConfigExtensions",
         value: input2
-      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_17._assertGuard(true, {
+      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_18._assertGuard(true, {
         method: "typia.createAssert",
         path: _path + "",
         expected: "TargetConfigExtensions",
@@ -11109,104 +11114,104 @@ function sha2562(content) {
 }
 
 // node_modules/.cache/mpgd-native-build/tools/target/generate-release-manifest.js
-import * as _assertGuard_19 from "typia/lib/internal/_assertGuard";
-import * as _accessExpressionAsString_110 from "typia/lib/internal/_accessExpressionAsString";
+import * as _assertGuard_110 from "typia/lib/internal/_assertGuard";
+import * as _accessExpressionAsString_111 from "typia/lib/internal/_accessExpressionAsString";
 import { execFileSync } from "node:child_process";
 import { createHash as createHash8, randomUUID as randomUUID2 } from "node:crypto";
 import { existsSync as existsSync10, readFileSync as readFileSync14, realpathSync as realpathSync6, renameSync as renameSync2, rmSync as rmSync5, writeFileSync as writeFileSync8 } from "node:fs";
 import { isAbsolute as isAbsolute8, relative as relative9, resolve as resolve12 } from "node:path";
-import typia11 from "typia";
+import typia12 from "typia";
 
 // node_modules/.cache/mpgd-native-build/packages/release-manifest/src/index.js
-import * as _assertGuard_18 from "typia/lib/internal/_assertGuard";
-import * as _accessExpressionAsString_19 from "typia/lib/internal/_accessExpressionAsString";
-import typia10 from "typia";
-var __typia_transform__accessExpressionAsString5 = _accessExpressionAsString_19._accessExpressionAsString;
+import * as _assertGuard_19 from "typia/lib/internal/_assertGuard";
+import * as _accessExpressionAsString_110 from "typia/lib/internal/_accessExpressionAsString";
+import typia11 from "typia";
+var __typia_transform__accessExpressionAsString5 = _accessExpressionAsString_110._accessExpressionAsString;
 var assertReleaseManifestStructure = /* @__PURE__ */ (() => {
   const _ip0 = (input) => "string" === typeof input["gameVersion"];
   const _ip1 = (input) => "string" === typeof input["path"];
   const _ip2 = (input) => "string" === typeof input["digest"];
-  const _ap0 = (input, _path, _exceptionable = true) => "string" === typeof input["gameVersion"] || _assertGuard_18._assertGuard(_exceptionable, {
+  const _ap0 = (input, _path, _exceptionable = true) => "string" === typeof input["gameVersion"] || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".gameVersion",
     expected: "string",
     value: input["gameVersion"]
   }, _errorFactory);
   const _ae0 = "{ readonly path: string; readonly digest: string; readonly sourceSha256: string; readonly sharedConfigSha256: string; readonly renderConfigSha256: string; readonly generatorVersion: string; readonly targetProfile: string; readonly targetProfileVersion: string; }";
-  const _ap1 = (input, _path, _exceptionable = true) => "string" === typeof input["path"] || _assertGuard_18._assertGuard(_exceptionable, {
+  const _ap1 = (input, _path, _exceptionable = true) => "string" === typeof input["path"] || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".path",
     expected: "string",
     value: input["path"]
   }, _errorFactory);
-  const _ap2 = (input, _path, _exceptionable = true) => "string" === typeof input["digest"] || _assertGuard_18._assertGuard(_exceptionable, {
+  const _ap2 = (input, _path, _exceptionable = true) => "string" === typeof input["digest"] || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".digest",
     expected: "string",
     value: input["digest"]
   }, _errorFactory);
-  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.releaseId || _assertGuard_18._assertGuard(_exceptionable, {
+  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.releaseId || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".releaseId",
     expected: "string",
     value: input.releaseId
-  }, _errorFactory)) && ("string" === typeof input.gitSha || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.gitSha || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".gitSha",
     expected: "string",
     value: input.gitSha
-  }, _errorFactory)) && ("string" === typeof input.kitGitSha || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.kitGitSha || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".kitGitSha",
     expected: "string",
     value: input.kitGitSha
-  }, _errorFactory)) && _ap0(input, _path, _exceptionable) && (void 0 === input.releaseIdentity || ("object" === typeof input.releaseIdentity && null !== input.releaseIdentity || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ap0(input, _path, _exceptionable) && (void 0 === input.releaseIdentity || ("object" === typeof input.releaseIdentity && null !== input.releaseIdentity || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".releaseIdentity",
     expected: "(MpgdReleaseIdentity | undefined)",
     value: input.releaseIdentity
-  }, _errorFactory)) && _ao1(input.releaseIdentity, _path + ".releaseIdentity", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao1(input.releaseIdentity, _path + ".releaseIdentity", _exceptionable) || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".releaseIdentity",
     expected: "(MpgdReleaseIdentity | undefined)",
     value: input.releaseIdentity
-  }, _errorFactory)) && ("string" === typeof input.buildId || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.buildId || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".buildId",
     expected: "string",
     value: input.buildId
-  }, _errorFactory)) && ("string" === typeof input.targetConfigVersion || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.targetConfigVersion || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".targetConfigVersion",
     expected: "string",
     value: input.targetConfigVersion
-  }, _errorFactory)) && ("string" === typeof input.catalogVersion || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.catalogVersion || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".catalogVersion",
     expected: "string",
     value: input.catalogVersion
-  }, _errorFactory)) && ("string" === typeof input.adPlacementVersion || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.adPlacementVersion || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".adPlacementVersion",
     expected: "string",
     value: input.adPlacementVersion
-  }, _errorFactory)) && (("object" === typeof input.targets && null !== input.targets && false === Array.isArray(input.targets) || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.targets && null !== input.targets && false === Array.isArray(input.targets) || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".targets",
     expected: "Record<string, ReleaseTargetManifest>",
     value: input.targets
-  }, _errorFactory)) && _ao2(input.targets, _path + ".targets", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao2(input.targets, _path + ".targets", _exceptionable) || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".targets",
     expected: "Record<string, ReleaseTargetManifest>",
     value: input.targets
   }, _errorFactory));
-  const _ao1 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && (void 0 === input.releaseRevision || "number" === typeof input.releaseRevision || _assertGuard_18._assertGuard(_exceptionable, {
+  const _ao1 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && (void 0 === input.releaseRevision || "number" === typeof input.releaseRevision || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".releaseRevision",
     expected: "(number | undefined)",
     value: input.releaseRevision
-  }, _errorFactory)) && ("string" === typeof input.label || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.label || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".label",
     expected: "string",
@@ -11216,142 +11221,142 @@ var assertReleaseManifestStructure = /* @__PURE__ */ (() => {
     const value = input[key];
     if (void 0 === value)
       return true;
-    return ("object" === typeof value && null !== value || _assertGuard_18._assertGuard(_exceptionable, {
+    return ("object" === typeof value && null !== value || _assertGuard_19._assertGuard(_exceptionable, {
       method: "typia.createAssert",
       path: _path + __typia_transform__accessExpressionAsString5(key),
       expected: "ReleaseTargetManifest",
       value
-    }, _errorFactory)) && _ao3(value, _path + __typia_transform__accessExpressionAsString5(key), _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
+    }, _errorFactory)) && _ao3(value, _path + __typia_transform__accessExpressionAsString5(key), _exceptionable) || _assertGuard_19._assertGuard(_exceptionable, {
       method: "typia.createAssert",
       path: _path + __typia_transform__accessExpressionAsString5(key),
       expected: "ReleaseTargetManifest",
       value
     }, _errorFactory);
   });
-  const _ao3 = (input, _path, _exceptionable = true) => ("string" === typeof input.artifact || _assertGuard_18._assertGuard(_exceptionable, {
+  const _ao3 = (input, _path, _exceptionable = true) => ("string" === typeof input.artifact || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".artifact",
     expected: "string",
     value: input.artifact
-  }, _errorFactory)) && (void 0 === input.profile || "string" === typeof input.profile || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.profile || "string" === typeof input.profile || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".profile",
     expected: "(string | undefined)",
     value: input.profile
-  }, _errorFactory)) && (("object" === typeof input.effectiveConfig && null !== input.effectiveConfig || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.effectiveConfig && null !== input.effectiveConfig || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".effectiveConfig",
     expected: "{ readonly path: string; readonly version: string; readonly digest: string; }",
     value: input.effectiveConfig
-  }, _errorFactory)) && _ao4(input.effectiveConfig, _path + ".effectiveConfig", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao4(input.effectiveConfig, _path + ".effectiveConfig", _exceptionable) || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".effectiveConfig",
     expected: "{ readonly path: string; readonly version: string; readonly digest: string; }",
     value: input.effectiveConfig
-  }, _errorFactory)) && (("object" === typeof input.iconManifest && null !== input.iconManifest || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.iconManifest && null !== input.iconManifest || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".iconManifest",
     expected: _ae0,
     value: input.iconManifest
-  }, _errorFactory)) && _ao5(input.iconManifest, _path + ".iconManifest", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao5(input.iconManifest, _path + ".iconManifest", _exceptionable) || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".iconManifest",
     expected: _ae0,
     value: input.iconManifest
-  }, _errorFactory)) && (void 0 === input.versionName || "string" === typeof input.versionName || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.versionName || "string" === typeof input.versionName || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".versionName",
     expected: "(string | undefined)",
     value: input.versionName
-  }, _errorFactory)) && (void 0 === input.versionCode || "number" === typeof input.versionCode || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.versionCode || "number" === typeof input.versionCode || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".versionCode",
     expected: "(number | undefined)",
     value: input.versionCode
-  }, _errorFactory)) && (void 0 === input.marketingVersion || "string" === typeof input.marketingVersion || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.marketingVersion || "string" === typeof input.marketingVersion || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".marketingVersion",
     expected: "(string | undefined)",
     value: input.marketingVersion
-  }, _errorFactory)) && (void 0 === input.buildNumber || "string" === typeof input.buildNumber || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.buildNumber || "string" === typeof input.buildNumber || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".buildNumber",
     expected: "(string | undefined)",
     value: input.buildNumber
-  }, _errorFactory)) && (void 0 === input.nativeDelivery || ("object" === typeof input.nativeDelivery && null !== input.nativeDelivery || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.nativeDelivery || ("object" === typeof input.nativeDelivery && null !== input.nativeDelivery || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".nativeDelivery",
     expected: "(ReleaseNativeDelivery | undefined)",
     value: input.nativeDelivery
-  }, _errorFactory)) && _ao6(input.nativeDelivery, _path + ".nativeDelivery", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao6(input.nativeDelivery, _path + ".nativeDelivery", _exceptionable) || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".nativeDelivery",
     expected: "(ReleaseNativeDelivery | undefined)",
     value: input.nativeDelivery
-  }, _errorFactory)) && (void 0 === input.appName || "string" === typeof input.appName || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.appName || "string" === typeof input.appName || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".appName",
     expected: "(string | undefined)",
     value: input.appName
-  }, _errorFactory)) && (void 0 === input.sdkMajor || "number" === typeof input.sdkMajor || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.sdkMajor || "number" === typeof input.sdkMajor || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".sdkMajor",
     expected: "(number | undefined)",
     value: input.sdkMajor
   }, _errorFactory));
-  const _ao4 = (input, _path, _exceptionable = true) => _ap1(input, _path, _exceptionable) && ("string" === typeof input.version || _assertGuard_18._assertGuard(_exceptionable, {
+  const _ao4 = (input, _path, _exceptionable = true) => _ap1(input, _path, _exceptionable) && ("string" === typeof input.version || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".version",
     expected: "string",
     value: input.version
   }, _errorFactory)) && _ap2(input, _path, _exceptionable);
-  const _ao5 = (input, _path, _exceptionable = true) => _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && ("string" === typeof input.sourceSha256 || _assertGuard_18._assertGuard(_exceptionable, {
+  const _ao5 = (input, _path, _exceptionable = true) => _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && ("string" === typeof input.sourceSha256 || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".sourceSha256",
     expected: "string",
     value: input.sourceSha256
-  }, _errorFactory)) && ("string" === typeof input.sharedConfigSha256 || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.sharedConfigSha256 || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".sharedConfigSha256",
     expected: "string",
     value: input.sharedConfigSha256
-  }, _errorFactory)) && ("string" === typeof input.renderConfigSha256 || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.renderConfigSha256 || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".renderConfigSha256",
     expected: "string",
     value: input.renderConfigSha256
-  }, _errorFactory)) && ("string" === typeof input.generatorVersion || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.generatorVersion || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".generatorVersion",
     expected: "string",
     value: input.generatorVersion
-  }, _errorFactory)) && ("string" === typeof input.targetProfile || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.targetProfile || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".targetProfile",
     expected: "string",
     value: input.targetProfile
-  }, _errorFactory)) && ("string" === typeof input.targetProfileVersion || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.targetProfileVersion || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".targetProfileVersion",
     expected: "string",
     value: input.targetProfileVersion
   }, _errorFactory));
-  const _ao6 = (input, _path, _exceptionable = true) => ("android" === input.platform || "ios" === input.platform || _assertGuard_18._assertGuard(_exceptionable, {
+  const _ao6 = (input, _path, _exceptionable = true) => ("android" === input.platform || "ios" === input.platform || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".platform",
     expected: '("android" | "ios")',
     value: input.platform
-  }, _errorFactory)) && ("debug" === input.mode || "signed-archive" === input.mode || "simulator" === input.mode || "store-export" === input.mode || "sync" === input.mode || "unsigned-archive" === input.mode || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("debug" === input.mode || "signed-archive" === input.mode || "simulator" === input.mode || "store-export" === input.mode || "sync" === input.mode || "unsigned-archive" === input.mode || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".mode",
     expected: '("debug" | "signed-archive" | "simulator" | "store-export" | "sync" | "unsigned-archive")',
     value: input.mode
-  }, _errorFactory)) && ("boolean" === typeof input.signed || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("boolean" === typeof input.signed || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".signed",
     expected: "boolean",
     value: input.signed
-  }, _errorFactory)) && ("boolean" === typeof input.submissionCandidate || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("boolean" === typeof input.submissionCandidate || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".submissionCandidate",
     expected: "boolean",
@@ -11374,12 +11379,12 @@ var assertReleaseManifestStructure = /* @__PURE__ */ (() => {
   return (input, errorFactory) => {
     if (false === __is(input)) {
       _errorFactory = errorFactory;
-      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_18._assertGuard(true, {
+      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_19._assertGuard(true, {
         method: "typia.createAssert",
         path: _path + "",
         expected: "ReleaseManifest",
         value: input2
-      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_18._assertGuard(true, {
+      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_19._assertGuard(true, {
         method: "typia.createAssert",
         path: _path + "",
         expected: "ReleaseManifest",
@@ -11541,164 +11546,164 @@ function canRecoverLock(lockFile) {
 }
 
 // node_modules/.cache/mpgd-native-build/tools/target/generate-release-manifest.js
-var __typia_transform__accessExpressionAsString6 = _accessExpressionAsString_110._accessExpressionAsString;
+var __typia_transform__accessExpressionAsString6 = _accessExpressionAsString_111._accessExpressionAsString;
 var assertProductCatalog = /* @__PURE__ */ (() => {
   const _ae0 = '({ readonly type: "currency"; readonly currency: string & MinLength<1>; readonly amount: PositiveLedgerAmount; } | { readonly type: "entitlement"; readonly entitlement: string; } | { readonly type: "resource"; readonly resource: string & MinLength<1>; readonly amount: number & ExclusiveMinimum<0> & Maximum<1.7976931348623157e+308>; })';
-  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.version || _assertGuard_19._assertGuard(_exceptionable, {
+  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.version || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".version",
     expected: "string",
     value: input.version
-  }, _errorFactory)) && (void 0 === input.currencies || (Array.isArray(input.currencies) || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.currencies || (Array.isArray(input.currencies) || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".currencies",
     expected: "((ReadonlyArray<string & MinLength<1>> & MinItems<1>) | undefined)",
     value: input.currencies
-  }, _errorFactory)) && ((1 <= input.currencies.length || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ((1 <= input.currencies.length || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".currencies",
     expected: "Array<> & MinItems<1>",
     value: input.currencies
-  }, _errorFactory)) && input.currencies.every((elem, _index3) => "string" === typeof elem && (1 <= elem.length || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) && input.currencies.every((elem, _index3) => "string" === typeof elem && (1 <= elem.length || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".currencies[" + _index3 + "]",
     expected: "string & MinLength<1>",
     value: elem
-  }, _errorFactory)) || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".currencies[" + _index3 + "]",
     expected: "(string & MinLength<1>)",
     value: elem
-  }, _errorFactory))) || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory))) || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".currencies",
     expected: "((ReadonlyArray<string & MinLength<1>> & MinItems<1>) | undefined)",
     value: input.currencies
-  }, _errorFactory)) && ((Array.isArray(input.products) || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ((Array.isArray(input.products) || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".products",
     expected: "ReadonlyArray<ProductCatalogEntry>",
     value: input.products
-  }, _errorFactory)) && input.products.every((elem, _index4) => ("object" === typeof elem && null !== elem || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) && input.products.every((elem, _index4) => ("object" === typeof elem && null !== elem || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".products[" + _index4 + "]",
     expected: "ProductCatalogEntry",
     value: elem
-  }, _errorFactory)) && _ao1(elem, _path + ".products[" + _index4 + "]", _exceptionable) || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao1(elem, _path + ".products[" + _index4 + "]", _exceptionable) || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".products[" + _index4 + "]",
     expected: "ProductCatalogEntry",
     value: elem
-  }, _errorFactory)) || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".products",
     expected: "ReadonlyArray<ProductCatalogEntry>",
     value: input.products
   }, _errorFactory));
-  const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || _assertGuard_19._assertGuard(_exceptionable, {
+  const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".id",
     expected: "string",
     value: input.id
-  }, _errorFactory)) && ("consumable" === input.type || "non_consumable" === input.type || "subscription" === input.type || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("consumable" === input.type || "non_consumable" === input.type || "subscription" === input.type || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".type",
     expected: '("consumable" | "non_consumable" | "subscription")',
     value: input.type
-  }, _errorFactory)) && (("object" === typeof input.grant && null !== input.grant || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.grant && null !== input.grant || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".grant",
     expected: _ae0,
     value: input.grant
-  }, _errorFactory)) && _au0(input.grant, _path + ".grant", _exceptionable) || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _au0(input.grant, _path + ".grant", _exceptionable) || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".grant",
     expected: _ae0,
     value: input.grant
-  }, _errorFactory)) && (("object" === typeof input.platformProductIds && null !== input.platformProductIds && false === Array.isArray(input.platformProductIds) || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.platformProductIds && null !== input.platformProductIds && false === Array.isArray(input.platformProductIds) || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".platformProductIds",
     expected: "Partial<Record<string, string>>",
     value: input.platformProductIds
-  }, _errorFactory)) && _ao5(input.platformProductIds, _path + ".platformProductIds", _exceptionable) || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao5(input.platformProductIds, _path + ".platformProductIds", _exceptionable) || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".platformProductIds",
     expected: "Partial<Record<string, string>>",
     value: input.platformProductIds
   }, _errorFactory));
-  const _ao2 = (input, _path, _exceptionable = true) => ("currency" === input.type || _assertGuard_19._assertGuard(_exceptionable, {
+  const _ao2 = (input, _path, _exceptionable = true) => ("currency" === input.type || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".type",
     expected: '"currency"',
     value: input.type
-  }, _errorFactory)) && ("string" === typeof input.currency && (1 <= input.currency.length || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.currency && (1 <= input.currency.length || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".currency",
     expected: "string & MinLength<1>",
     value: input.currency
-  }, _errorFactory)) || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".currency",
     expected: "(string & MinLength<1>)",
     value: input.currency
-  }, _errorFactory)) && ("number" === typeof input.amount && (1 <= input.amount || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("number" === typeof input.amount && (1 <= input.amount || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".amount",
     expected: "number & Minimum<1>",
     value: input.amount
-  }, _errorFactory)) && (input.amount <= 9007199254740991 || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (input.amount <= 9007199254740991 || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".amount",
     expected: "number & Maximum<9007199254740991>",
     value: input.amount
-  }, _errorFactory)) && (input.amount % 1 === 0 || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (input.amount % 1 === 0 || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".amount",
     expected: "number & MultipleOf<1>",
     value: input.amount
-  }, _errorFactory)) || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".amount",
     expected: "(number & Minimum<1> & Maximum<9007199254740991> & MultipleOf<1>)",
     value: input.amount
   }, _errorFactory));
-  const _ao3 = (input, _path, _exceptionable = true) => ("entitlement" === input.type || _assertGuard_19._assertGuard(_exceptionable, {
+  const _ao3 = (input, _path, _exceptionable = true) => ("entitlement" === input.type || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".type",
     expected: '"entitlement"',
     value: input.type
-  }, _errorFactory)) && ("string" === typeof input.entitlement || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.entitlement || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".entitlement",
     expected: "string",
     value: input.entitlement
   }, _errorFactory));
-  const _ao4 = (input, _path, _exceptionable = true) => ("resource" === input.type || _assertGuard_19._assertGuard(_exceptionable, {
+  const _ao4 = (input, _path, _exceptionable = true) => ("resource" === input.type || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".type",
     expected: '"resource"',
     value: input.type
-  }, _errorFactory)) && ("string" === typeof input.resource && (1 <= input.resource.length || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.resource && (1 <= input.resource.length || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".resource",
     expected: "string & MinLength<1>",
     value: input.resource
-  }, _errorFactory)) || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".resource",
     expected: "(string & MinLength<1>)",
     value: input.resource
-  }, _errorFactory)) && ("number" === typeof input.amount && (0 < input.amount || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("number" === typeof input.amount && (0 < input.amount || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".amount",
     expected: "number & ExclusiveMinimum<0>",
     value: input.amount
-  }, _errorFactory)) && (input.amount <= 17976931348623157e292 || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (input.amount <= 17976931348623157e292 || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".amount",
     expected: "number & Maximum<1.7976931348623157e+308>",
     value: input.amount
-  }, _errorFactory)) || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".amount",
     expected: "(number & ExclusiveMinimum<0> & Maximum<1.7976931348623157e+308>)",
@@ -11708,7 +11713,7 @@ var assertProductCatalog = /* @__PURE__ */ (() => {
     const value = input[key];
     if (void 0 === value)
       return true;
-    return void 0 === value || "string" === typeof value || _assertGuard_19._assertGuard(_exceptionable, {
+    return void 0 === value || "string" === typeof value || _assertGuard_110._assertGuard(_exceptionable, {
       method: "typia.createAssert",
       path: _path + __typia_transform__accessExpressionAsString6(key),
       expected: "(string | undefined)",
@@ -11723,7 +11728,7 @@ var assertProductCatalog = /* @__PURE__ */ (() => {
     else if ("resource" === input.type)
       return _ao4(input, _path, _exceptionable);
     else
-      return _assertGuard_19._assertGuard(_exceptionable, {
+      return _assertGuard_110._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path,
         expected: _ae0,
@@ -11756,12 +11761,12 @@ var assertProductCatalog = /* @__PURE__ */ (() => {
   return (input, errorFactory) => {
     if (false === __is(input)) {
       _errorFactory = errorFactory;
-      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_19._assertGuard(true, {
+      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_110._assertGuard(true, {
         method: "typia.createAssert",
         path: _path + "",
         expected: "ProductCatalog",
         value: input2
-      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_19._assertGuard(true, {
+      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_110._assertGuard(true, {
         method: "typia.createAssert",
         path: _path + "",
         expected: "ProductCatalog",
@@ -11775,122 +11780,122 @@ var assertAdPlacements = /* @__PURE__ */ (() => {
   const _ip0 = (input) => "number" === typeof input["amount"] && (1 <= input["amount"] && input["amount"] <= 9007199254740991 && input["amount"] % 1 === 0);
   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: PositiveLedgerAmount; } | { readonly type: "currency"; readonly amount: PositiveLedgerAmount; readonly currency: string & MinLength<1>; })';
-  const _ap0 = (input, _path, _exceptionable = true) => "number" === typeof input["amount"] && (1 <= input["amount"] || _assertGuard_19._assertGuard(_exceptionable, {
+  const _ap0 = (input, _path, _exceptionable = true) => "number" === typeof input["amount"] && (1 <= input["amount"] || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".amount",
     expected: "number & Minimum<1>",
     value: input["amount"]
-  }, _errorFactory)) && (input["amount"] <= 9007199254740991 || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (input["amount"] <= 9007199254740991 || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".amount",
     expected: "number & Maximum<9007199254740991>",
     value: input["amount"]
-  }, _errorFactory)) && (input["amount"] % 1 === 0 || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (input["amount"] % 1 === 0 || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".amount",
     expected: "number & MultipleOf<1>",
     value: input["amount"]
-  }, _errorFactory)) || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".amount",
     expected: "(number & Minimum<1> & Maximum<9007199254740991> & MultipleOf<1>)",
     value: input["amount"]
   }, _errorFactory);
   const _ae2 = '({ readonly type: "continue"; readonly amount: PositiveLedgerAmount; } | { readonly type: "currency"; readonly amount: PositiveLedgerAmount; readonly currency: string & MinLength<1>; })';
-  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.version || _assertGuard_19._assertGuard(_exceptionable, {
+  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.version || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".version",
     expected: "string",
     value: input.version
-  }, _errorFactory)) && ((Array.isArray(input.placements) || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ((Array.isArray(input.placements) || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".placements",
     expected: "ReadonlyArray<AdPlacementEntry>",
     value: input.placements
-  }, _errorFactory)) && input.placements.every((elem, _index3) => ("object" === typeof elem && null !== elem || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) && input.placements.every((elem, _index3) => ("object" === typeof elem && null !== elem || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".placements[" + _index3 + "]",
     expected: _ae0,
     value: elem
-  }, _errorFactory)) && _au0(elem, _path + ".placements[" + _index3 + "]", _exceptionable) || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _au0(elem, _path + ".placements[" + _index3 + "]", _exceptionable) || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".placements[" + _index3 + "]",
     expected: _ae0,
     value: elem
-  }, _errorFactory)) || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".placements",
     expected: "ReadonlyArray<AdPlacementEntry>",
     value: input.placements
-  }, _errorFactory)) && (void 0 === input.sharedPlatformPlacementTargets || (Array.isArray(input.sharedPlatformPlacementTargets) || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.sharedPlatformPlacementTargets || (Array.isArray(input.sharedPlatformPlacementTargets) || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".sharedPlatformPlacementTargets",
     expected: "(ReadonlyArray<string> | undefined)",
     value: input.sharedPlatformPlacementTargets
-  }, _errorFactory)) && input.sharedPlatformPlacementTargets.every((elem, _index4) => "string" === typeof elem || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) && input.sharedPlatformPlacementTargets.every((elem, _index4) => "string" === typeof elem || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".sharedPlatformPlacementTargets[" + _index4 + "]",
     expected: "string",
     value: elem
-  }, _errorFactory)) || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".sharedPlatformPlacementTargets",
     expected: "(ReadonlyArray<string> | undefined)",
     value: input.sharedPlatformPlacementTargets
   }, _errorFactory));
-  const _ao1 = (input, _path, _exceptionable = true) => _ao2(input, _path, _exceptionable) && (("rewarded" === input.type || _assertGuard_19._assertGuard(_exceptionable, {
+  const _ao1 = (input, _path, _exceptionable = true) => _ao2(input, _path, _exceptionable) && (("rewarded" === input.type || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".type",
     expected: '"rewarded"',
     value: input.type
-  }, _errorFactory)) && (void 0 === input.reward || ("object" === typeof input.reward && null !== input.reward || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.reward || ("object" === typeof input.reward && null !== input.reward || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".reward",
     expected: _ae1,
     value: input.reward
-  }, _errorFactory)) && _au1(input.reward, _path + ".reward", _exceptionable) || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _au1(input.reward, _path + ".reward", _exceptionable) || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".reward",
     expected: _ae1,
     value: input.reward
   }, _errorFactory)));
-  const _ao2 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || _assertGuard_19._assertGuard(_exceptionable, {
+  const _ao2 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".id",
     expected: "string",
     value: input.id
-  }, _errorFactory)) && (("object" === typeof input.frequencyCap && null !== input.frequencyCap || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.frequencyCap && null !== input.frequencyCap || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".frequencyCap",
     expected: "FrequencyCap",
     value: input.frequencyCap
-  }, _errorFactory)) && _ao3(input.frequencyCap, _path + ".frequencyCap", _exceptionable) || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao3(input.frequencyCap, _path + ".frequencyCap", _exceptionable) || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".frequencyCap",
     expected: "FrequencyCap",
     value: input.frequencyCap
-  }, _errorFactory)) && (("object" === typeof input.platformPlacementIds && null !== input.platformPlacementIds && false === Array.isArray(input.platformPlacementIds) || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.platformPlacementIds && null !== input.platformPlacementIds && false === Array.isArray(input.platformPlacementIds) || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".platformPlacementIds",
     expected: "Partial<Record<string, string>>",
     value: input.platformPlacementIds
-  }, _errorFactory)) && _ao4(input.platformPlacementIds, _path + ".platformPlacementIds", _exceptionable) || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao4(input.platformPlacementIds, _path + ".platformPlacementIds", _exceptionable) || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".platformPlacementIds",
     expected: "Partial<Record<string, string>>",
     value: input.platformPlacementIds
   }, _errorFactory));
-  const _ao3 = (input, _path, _exceptionable = true) => ("number" === typeof input.cooldownSeconds || _assertGuard_19._assertGuard(_exceptionable, {
+  const _ao3 = (input, _path, _exceptionable = true) => ("number" === typeof input.cooldownSeconds || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".cooldownSeconds",
     expected: "number",
     value: input.cooldownSeconds
-  }, _errorFactory)) && (void 0 === input.maxPerSession || "number" === typeof input.maxPerSession || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.maxPerSession || "number" === typeof input.maxPerSession || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".maxPerSession",
     expected: "(number | undefined)",
     value: input.maxPerSession
-  }, _errorFactory)) && (void 0 === input.minStageInterval || "number" === typeof input.minStageInterval || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.minStageInterval || "number" === typeof input.minStageInterval || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".minStageInterval",
     expected: "(number | undefined)",
@@ -11900,46 +11905,46 @@ var assertAdPlacements = /* @__PURE__ */ (() => {
     const value = input[key];
     if (void 0 === value)
       return true;
-    return void 0 === value || "string" === typeof value || _assertGuard_19._assertGuard(_exceptionable, {
+    return void 0 === value || "string" === typeof value || _assertGuard_110._assertGuard(_exceptionable, {
       method: "typia.createAssert",
       path: _path + __typia_transform__accessExpressionAsString6(key),
       expected: "(string | undefined)",
       value
     }, _errorFactory);
   });
-  const _ao5 = (input, _path, _exceptionable = true) => ("continue" === input.type || _assertGuard_19._assertGuard(_exceptionable, {
+  const _ao5 = (input, _path, _exceptionable = true) => ("continue" === input.type || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".type",
     expected: '"continue"',
     value: input.type
   }, _errorFactory)) && _ap0(input, _path, _exceptionable);
-  const _ao6 = (input, _path, _exceptionable = true) => ("currency" === input.type || _assertGuard_19._assertGuard(_exceptionable, {
+  const _ao6 = (input, _path, _exceptionable = true) => ("currency" === input.type || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".type",
     expected: '"currency"',
     value: input.type
-  }, _errorFactory)) && _ap0(input, _path, _exceptionable) && ("string" === typeof input.currency && (1 <= input.currency.length || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ap0(input, _path, _exceptionable) && ("string" === typeof input.currency && (1 <= input.currency.length || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".currency",
     expected: "string & MinLength<1>",
     value: input.currency
-  }, _errorFactory)) || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".currency",
     expected: "(string & MinLength<1>)",
     value: input.currency
   }, _errorFactory));
-  const _ao7 = (input, _path, _exceptionable = true) => _ao2(input, _path, _exceptionable) && (("banner" === input.type || "interstitial" === input.type || _assertGuard_19._assertGuard(_exceptionable, {
+  const _ao7 = (input, _path, _exceptionable = true) => _ao2(input, _path, _exceptionable) && (("banner" === input.type || "interstitial" === input.type || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".type",
     expected: '("banner" | "interstitial")',
     value: input.type
-  }, _errorFactory)) && ((null !== input.reward || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ((null !== input.reward || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".reward",
     expected: "undefined",
     value: input.reward
-  }, _errorFactory)) && (void 0 === input.reward || _assertGuard_19._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.reward || _assertGuard_110._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".reward",
     expected: "undefined",
@@ -11951,7 +11956,7 @@ var assertAdPlacements = /* @__PURE__ */ (() => {
     else if ("rewarded" === input.type)
       return _ao1(input, _path, _exceptionable);
     else
-      return _assertGuard_19._assertGuard(_exceptionable, {
+      return _assertGuard_110._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path,
         expected: _ae0,
@@ -11964,7 +11969,7 @@ var assertAdPlacements = /* @__PURE__ */ (() => {
     else if ("currency" === input.type)
       return _ao6(input, _path, _exceptionable);
     else
-      return _assertGuard_19._assertGuard(_exceptionable, {
+      return _assertGuard_110._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path,
         expected: _ae2,
@@ -12005,12 +12010,12 @@ var assertAdPlacements = /* @__PURE__ */ (() => {
   return (input, errorFactory) => {
     if (false === __is(input)) {
       _errorFactory = errorFactory;
-      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_19._assertGuard(true, {
+      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_110._assertGuard(true, {
         method: "typia.createAssert",
         path: _path + "",
         expected: "AdPlacements",
         value: input2
-      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_19._assertGuard(true, {
+      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_110._assertGuard(true, {
         method: "typia.createAssert",
         path: _path + "",
         expected: "AdPlacements",