@mpgd/target-config 0.3.4 → 0.5.0

package/dist/effective.d.ts

@@ -1,5 +1,5 @@
 import type { AdPlacementEntry, AdPlacements, ProductCatalog, ProductCatalogEntry } from '@mpgd/catalog';
-import type { FeatureAvailabilityReason, TargetCapabilityConfig, TargetConfig, TargetConfigMatrix, TargetFeatureConfig, TargetPolicyRestrictions, TargetReleaseConfig, TargetRuntimeKind } from './runtime';
+import { type FeatureAvailabilityReason, type TargetCapabilityConfig, type TargetConfig, type TargetConfigMatrix, type TargetFeatureConfig, type TargetIntegrationConfig, type TargetPolicyRestrictions, type TargetReleaseConfig, type TargetRuntimeKind } from './runtime.js';
 export type EffectiveAvailabilityReason = FeatureAvailabilityReason | 'missing-platform-id';
 export interface EffectivePlatformTargetMetadata {
   readonly kind: string;
@@ -61,6 +61,7 @@ export interface EffectiveTargetConfig {
   readonly release: TargetReleaseConfig;
   readonly features: TargetFeatureConfig;
   readonly capabilities: TargetCapabilityConfig;
+  readonly integrations: TargetIntegrationConfig;
   readonly policy: TargetPolicyRestrictions;
   readonly sources: EffectiveTargetConfigSources;
   readonly monetization: EffectiveMonetizationConfig;

package/dist/effective.js

@@ -1,3 +1,4 @@
+import { normalizeTargetIntegrationConfig, } from './runtime.js';
 export const defaultLeaderboardId = 'default';
 export function createEffectiveTargetConfig(input) {
     const products = input.catalog.products.map((product) => createEffectiveProductConfig(input.target, input.config, product));
@@ -14,6 +15,7 @@ export function createEffectiveTargetConfig(input) {
         release: input.config.release,
         features: input.config.features,
         capabilities: input.config.capabilities,
+        integrations: normalizeTargetIntegrationConfig(input.config.integrations),
         policy: input.config.policy,
         sources: {
             targetConfig: input.targetConfigVersion,

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import type { EffectiveTargetConfigMatrix } from './effective';
-import type { TargetConfigMatrix } from './runtime';
-export * from './effective';
-export * from './runtime';
-export * from './viewport';
+import type { EffectiveTargetConfigMatrix } from './effective.js';
+import type { TargetConfigMatrix } from './runtime.js';
+export * from './effective.js';
+export * from './runtime.js';
+export * from './viewport.js';
 export declare const assertEffectiveTargetConfigMatrix: (input: unknown) => EffectiveTargetConfigMatrix;
 export declare const assertTargetConfigMatrix: (input: unknown) => TargetConfigMatrix;

package/dist/index.js

@@ -2,20 +2,21 @@ import * as _a from "typia/lib/internal/_assertGuard";
 import * as _b from "typia/lib/internal/_accessExpressionAsString";
 const __typia_transform__accessExpressionAsString = _b._accessExpressionAsString;
 import typia from 'typia';
-export * from './effective';
-export * from './runtime';
-export * from './viewport';
+export * from './effective.js';
+export * from './runtime.js';
+export * from './viewport.js';
 export const assertEffectiveTargetConfigMatrix = (() => {
     const _ip0 = input => "string" === typeof input["version"];
     const _ip1 = input => "boolean" === typeof input["iap"];
     const _ip2 = input => "boolean" === typeof input["rewardedAds"];
     const _ip3 = input => "boolean" === typeof input["interstitialAds"];
     const _ip4 = input => "boolean" === typeof input["localization"];
-    const _ip5 = input => "boolean" === typeof input["enabled"];
-    const _ip6 = input => "available" === input["reason"] || "capability-unsupported" === input["reason"] || "missing-platform-id" === input["reason"] || "target-disabled" === input["reason"];
-    const _ip7 = input => "currency" === input["type"];
-    const _ip8 = input => "coin" === input["currency"] || "gem" === input["currency"];
-    const _ip9 = input => "number" === typeof input["amount"];
+    const _ip5 = input => "string" === typeof input["id"];
+    const _ip6 = input => "boolean" === typeof input["enabled"];
+    const _ip7 = input => "available" === input["reason"] || "capability-unsupported" === input["reason"] || "missing-platform-id" === input["reason"] || "target-disabled" === input["reason"];
+    const _ip8 = input => "currency" === input["type"];
+    const _ip9 = input => "coin" === input["currency"] || "gem" === input["currency"];
+    const _ip10 = input => "number" === typeof input["amount"];
     const _ap0 = (input, _path, _exceptionable = true) => "string" === typeof input["version"] || _a._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".version",
@@ -46,32 +47,38 @@ export const assertEffectiveTargetConfigMatrix = (() => {
         expected: "boolean",
         value: input["localization"]
     }, _errorFactory);
+    const _ap5 = (input, _path, _exceptionable = true) => "string" === typeof input["id"] || _a._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".id",
+        expected: "string",
+        value: input["id"]
+    }, _errorFactory);
     const _ae0 = "({ readonly type: \"currency\"; readonly currency: \"coin\" | \"gem\"; readonly amount: number; } | { readonly type: \"entitlement\"; readonly entitlement: string; })";
-    const _ap5 = (input, _path, _exceptionable = true) => "boolean" === typeof input["enabled"] || _a._assertGuard(_exceptionable, {
+    const _ap6 = (input, _path, _exceptionable = true) => "boolean" === typeof input["enabled"] || _a._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".enabled",
         expected: "boolean",
         value: input["enabled"]
     }, _errorFactory);
-    const _ap6 = (input, _path, _exceptionable = true) => "available" === input["reason"] || "capability-unsupported" === input["reason"] || "missing-platform-id" === input["reason"] || "target-disabled" === input["reason"] || _a._assertGuard(_exceptionable, {
+    const _ap7 = (input, _path, _exceptionable = true) => "available" === input["reason"] || "capability-unsupported" === input["reason"] || "missing-platform-id" === input["reason"] || "target-disabled" === input["reason"] || _a._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".reason",
         expected: "(\"available\" | \"capability-unsupported\" | \"missing-platform-id\" | \"target-disabled\")",
         value: input["reason"]
     }, _errorFactory);
-    const _ap7 = (input, _path, _exceptionable = true) => "currency" === input["type"] || _a._assertGuard(_exceptionable, {
+    const _ap8 = (input, _path, _exceptionable = true) => "currency" === input["type"] || _a._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".type",
         expected: "\"currency\"",
         value: input["type"]
     }, _errorFactory);
-    const _ap8 = (input, _path, _exceptionable = true) => "coin" === input["currency"] || "gem" === input["currency"] || _a._assertGuard(_exceptionable, {
+    const _ap9 = (input, _path, _exceptionable = true) => "coin" === input["currency"] || "gem" === input["currency"] || _a._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".currency",
         expected: "(\"coin\" | \"gem\")",
         value: input["currency"]
     }, _errorFactory);
-    const _ap9 = (input, _path, _exceptionable = true) => "number" === typeof input["amount"] || _a._assertGuard(_exceptionable, {
+    const _ap10 = (input, _path, _exceptionable = true) => "number" === typeof input["amount"] || _a._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".amount",
         expected: "number",
@@ -106,8 +113,29 @@ export const assertEffectiveTargetConfigMatrix = (() => {
             value: value
         }, _errorFactory);
     });
-    const _ao10 = (input, _path, _exceptionable = true) => _ap7(input, _path, true && _exceptionable) && _ap8(input, _path, true && _exceptionable) && _ap9(input, _path, true && _exceptionable);
-    const _ao11 = (input, _path, _exceptionable = true) => ("entitlement" === input.type || _a._assertGuard(_exceptionable, {
+    const _ao10 = (input, _path, _exceptionable = true) => _ap5(input, _path, true && _exceptionable) && ("consumable" === input.type || "non_consumable" === input.type || "subscription" === input.type || _a._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".type",
+        expected: "(\"consumable\" | \"non_consumable\" | \"subscription\")",
+        value: input.type
+    }, _errorFactory)) && (("object" === typeof input.grant && null !== input.grant || _a._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".grant",
+        expected: _ae0,
+        value: input.grant
+    }, _errorFactory)) && _au0(input.grant, _path + ".grant", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".grant",
+        expected: _ae0,
+        value: input.grant
+    }, _errorFactory)) && _ap6(input, _path, true && _exceptionable) && _ap7(input, _path, true && _exceptionable) && (undefined === input.platformProductId || "string" === typeof input.platformProductId || _a._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".platformProductId",
+        expected: "(string | undefined)",
+        value: input.platformProductId
+    }, _errorFactory));
+    const _ao11 = (input, _path, _exceptionable = true) => _ap8(input, _path, true && _exceptionable) && _ap9(input, _path, true && _exceptionable) && _ap10(input, _path, true && _exceptionable);
+    const _ao12 = (input, _path, _exceptionable = true) => ("entitlement" === input.type || _a._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".type",
         expected: "\"entitlement\"",
@@ -118,7 +146,7 @@ export const assertEffectiveTargetConfigMatrix = (() => {
         expected: "string",
         value: input.entitlement
     }, _errorFactory));
-    const _ao12 = (input, _path, _exceptionable = true) => _ap2(input, _path, true && _exceptionable) && _ap3(input, _path, true && _exceptionable) && ((Array.isArray(input.placements) || _a._assertGuard(_exceptionable, {
+    const _ao13 = (input, _path, _exceptionable = true) => _ap2(input, _path, true && _exceptionable) && _ap3(input, _path, true && _exceptionable) && ((Array.isArray(input.placements) || _a._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".placements",
         expected: "ReadonlyArray<EffectiveAdPlacementConfig>",
@@ -128,7 +156,7 @@ export const assertEffectiveTargetConfigMatrix = (() => {
         path: _path + ".placements[" + _index4 + "]",
         expected: "EffectiveAdPlacementConfig",
         value: elem
-    }, _errorFactory)) && _ao13(elem, _path + ".placements[" + _index4 + "]", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+    }, _errorFactory)) && _ao14(elem, _path + ".placements[" + _index4 + "]", true && _exceptionable) || _a._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".placements[" + _index4 + "]",
         expected: "EffectiveAdPlacementConfig",
@@ -139,12 +167,7 @@ export const assertEffectiveTargetConfigMatrix = (() => {
         expected: "ReadonlyArray<EffectiveAdPlacementConfig>",
         value: input.placements
     }, _errorFactory));
-    const _ao13 = (input, _path, _exceptionable = true) => ("CONTINUE_AFTER_FAIL" === input.id || "STAGE_END_INTERSTITIAL" === input.id || _a._assertGuard(_exceptionable, {
-        method: "typia.createAssert",
-        path: _path + ".id",
-        expected: "(\"CONTINUE_AFTER_FAIL\" | \"STAGE_END_INTERSTITIAL\")",
-        value: input.id
-    }, _errorFactory)) && ("interstitial" === input.type || "rewarded" === input.type || _a._assertGuard(_exceptionable, {
+    const _ao14 = (input, _path, _exceptionable = true) => _ap5(input, _path, true && _exceptionable) && ("interstitial" === input.type || "rewarded" === input.type || _a._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".type",
         expected: "(\"interstitial\" | \"rewarded\")",
@@ -164,25 +187,25 @@ export const assertEffectiveTargetConfigMatrix = (() => {
         path: _path + ".frequencyCap",
         expected: "FrequencyCap",
         value: input.frequencyCap
-    }, _errorFactory)) && _ao16(input.frequencyCap, _path + ".frequencyCap", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+    }, _errorFactory)) && _ao17(input.frequencyCap, _path + ".frequencyCap", true && _exceptionable) || _a._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".frequencyCap",
         expected: "FrequencyCap",
         value: input.frequencyCap
-    }, _errorFactory)) && _ap5(input, _path, true && _exceptionable) && _ap6(input, _path, true && _exceptionable) && (undefined === input.platformPlacementId || "string" === typeof input.platformPlacementId || _a._assertGuard(_exceptionable, {
+    }, _errorFactory)) && _ap6(input, _path, true && _exceptionable) && _ap7(input, _path, true && _exceptionable) && (undefined === input.platformPlacementId || "string" === typeof input.platformPlacementId || _a._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".platformPlacementId",
         expected: "(string | undefined)",
         value: input.platformPlacementId
     }, _errorFactory));
-    const _ao14 = (input, _path, _exceptionable = true) => ("continue" === input.type || _a._assertGuard(_exceptionable, {
+    const _ao15 = (input, _path, _exceptionable = true) => ("continue" === input.type || _a._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".type",
         expected: "\"continue\"",
         value: input.type
-    }, _errorFactory)) && _ap9(input, _path, true && _exceptionable);
-    const _ao15 = (input, _path, _exceptionable = true) => _ap7(input, _path, true && _exceptionable) && _ap9(input, _path, true && _exceptionable) && _ap8(input, _path, true && _exceptionable);
-    const _ao16 = (input, _path, _exceptionable = true) => ("number" === typeof input.cooldownSeconds || _a._assertGuard(_exceptionable, {
+    }, _errorFactory)) && _ap10(input, _path, true && _exceptionable);
+    const _ao16 = (input, _path, _exceptionable = true) => _ap8(input, _path, true && _exceptionable) && _ap10(input, _path, true && _exceptionable) && _ap9(input, _path, true && _exceptionable);
+    const _ao17 = (input, _path, _exceptionable = true) => ("number" === typeof input.cooldownSeconds || _a._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".cooldownSeconds",
         expected: "number",
@@ -198,12 +221,12 @@ export const assertEffectiveTargetConfigMatrix = (() => {
         expected: "(number | undefined)",
         value: input.minStageInterval
     }, _errorFactory));
-    const _ao17 = (input, _path, _exceptionable = true) => ("boolean" === typeof input.native || _a._assertGuard(_exceptionable, {
+    const _ao18 = (input, _path, _exceptionable = true) => ("boolean" === typeof input.native || _a._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".native",
         expected: "boolean",
         value: input.native
-    }, _errorFactory)) && _ap5(input, _path, true && _exceptionable) && ("available" === input.reason || "capability-unsupported" === input.reason || "target-disabled" === input.reason || _a._assertGuard(_exceptionable, {
+    }, _errorFactory)) && _ap6(input, _path, true && _exceptionable) && ("available" === input.reason || "capability-unsupported" === input.reason || "target-disabled" === input.reason || _a._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".reason",
         expected: "(\"available\" | \"capability-unsupported\" | \"target-disabled\")",
@@ -214,13 +237,12 @@ export const assertEffectiveTargetConfigMatrix = (() => {
         expected: "(string | undefined)",
         value: input.defaultLeaderboardId
     }, _errorFactory));
-    const _ao18 = (input, _path, _exceptionable = true) => ("local" === input.support || "native" === input.support || "none" === input.support || _a._assertGuard(_exceptionable, {
+    const _ao19 = (input, _path, _exceptionable = true) => ("local" === input.support || "native" === input.support || "none" === input.support || _a._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".support",
         expected: "(\"local\" | \"native\" | \"none\")",
         value: input.support
-    }, _errorFactory)) && _ap5(input, _path, true && _exceptionable);
-    const _ao19 = (input, _path, _exceptionable = true) => _ap5(input, _path, true && _exceptionable);
+    }, _errorFactory)) && _ap6(input, _path, true && _exceptionable);
     const _ao2 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && ("string" === typeof input.target || _a._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".target",
@@ -261,12 +283,22 @@ export const assertEffectiveTargetConfigMatrix = (() => {
         path: _path + ".capabilities",
         expected: "TargetCapabilityConfig",
         value: input.capabilities
+    }, _errorFactory)) && (("object" === typeof input.integrations && null !== input.integrations || _a._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".integrations",
+        expected: "TargetIntegrationConfig",
+        value: input.integrations
+    }, _errorFactory)) && _ao6(input.integrations, _path + ".integrations", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".integrations",
+        expected: "TargetIntegrationConfig",
+        value: input.integrations
     }, _errorFactory)) && (("object" === typeof input.policy && null !== input.policy || _a._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".policy",
         expected: "TargetPolicyRestrictions",
         value: input.policy
-    }, _errorFactory)) && _ao6(input.policy, _path + ".policy", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+    }, _errorFactory)) && _ao7(input.policy, _path + ".policy", true && _exceptionable) || _a._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".policy",
         expected: "TargetPolicyRestrictions",
@@ -276,7 +308,7 @@ export const assertEffectiveTargetConfigMatrix = (() => {
         path: _path + ".sources",
         expected: "EffectiveTargetConfigSources",
         value: input.sources
-    }, _errorFactory)) && _ao7(input.sources, _path + ".sources", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+    }, _errorFactory)) && _ao8(input.sources, _path + ".sources", true && _exceptionable) || _a._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".sources",
         expected: "EffectiveTargetConfigSources",
@@ -286,7 +318,7 @@ export const assertEffectiveTargetConfigMatrix = (() => {
         path: _path + ".monetization",
         expected: "EffectiveMonetizationConfig",
         value: input.monetization
-    }, _errorFactory)) && _ao8(input.monetization, _path + ".monetization", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+    }, _errorFactory)) && _ao9(input.monetization, _path + ".monetization", true && _exceptionable) || _a._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".monetization",
         expected: "EffectiveMonetizationConfig",
@@ -296,7 +328,7 @@ export const assertEffectiveTargetConfigMatrix = (() => {
         path: _path + ".ads",
         expected: "EffectiveAdsConfig",
         value: input.ads
-    }, _errorFactory)) && _ao12(input.ads, _path + ".ads", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+    }, _errorFactory)) && _ao13(input.ads, _path + ".ads", true && _exceptionable) || _a._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".ads",
         expected: "EffectiveAdsConfig",
@@ -306,7 +338,7 @@ export const assertEffectiveTargetConfigMatrix = (() => {
         path: _path + ".leaderboard",
         expected: "EffectiveLeaderboardConfig",
         value: input.leaderboard
-    }, _errorFactory)) && _ao17(input.leaderboard, _path + ".leaderboard", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+    }, _errorFactory)) && _ao18(input.leaderboard, _path + ".leaderboard", true && _exceptionable) || _a._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".leaderboard",
         expected: "EffectiveLeaderboardConfig",
@@ -316,7 +348,7 @@ export const assertEffectiveTargetConfigMatrix = (() => {
         path: _path + ".storage",
         expected: "EffectiveStorageConfig",
         value: input.storage
-    }, _errorFactory)) && _ao18(input.storage, _path + ".storage", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+    }, _errorFactory)) && _ao19(input.storage, _path + ".storage", true && _exceptionable) || _a._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".storage",
         expected: "EffectiveStorageConfig",
@@ -326,12 +358,13 @@ export const assertEffectiveTargetConfigMatrix = (() => {
         path: _path + ".localization",
         expected: "EffectiveLocalizationConfig",
         value: input.localization
-    }, _errorFactory)) && _ao19(input.localization, _path + ".localization", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+    }, _errorFactory)) && _ao20(input.localization, _path + ".localization", true && _exceptionable) || _a._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".localization",
         expected: "EffectiveLocalizationConfig",
         value: input.localization
     }, _errorFactory));
+    const _ao20 = (input, _path, _exceptionable = true) => _ap6(input, _path, true && _exceptionable);
     const _ao3 = (input, _path, _exceptionable = true) => "app-store" === input.profile || "apps-in-toss" === input.profile || "devvit" === input.profile || "google-play" === input.profile || "microsoft-store" === input.profile || "web-preview" === input.profile || _a._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".profile",
@@ -350,7 +383,38 @@ export const assertEffectiveTargetConfigMatrix = (() => {
         expected: "(\"local\" | \"native\" | \"none\")",
         value: input.storage
     }, _errorFactory)) && _ap4(input, _path, true && _exceptionable);
-    const _ao6 = (input, _path, _exceptionable = true) => ("boolean" === typeof input.externalPaymentAllowed || _a._assertGuard(_exceptionable, {
+    const _ao6 = (input, _path, _exceptionable = true) => ("approval-required" === input.identityUpgrade || "available" === input.identityUpgrade || "configuration-required" === input.identityUpgrade || "disabled" === input.identityUpgrade || "unsupported" === input.identityUpgrade || _a._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".identityUpgrade",
+        expected: "(\"approval-required\" | \"available\" | \"configuration-required\" | \"disabled\" | \"unsupported\")",
+        value: input.identityUpgrade
+    }, _errorFactory)) && ("approval-required" === input.presentation || "available" === input.presentation || "configuration-required" === input.presentation || "disabled" === input.presentation || "unsupported" === input.presentation || _a._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".presentation",
+        expected: "(\"approval-required\" | \"available\" | \"configuration-required\" | \"disabled\" | \"unsupported\")",
+        value: input.presentation
+    }, _errorFactory)) && ("approval-required" === input.sharing || "available" === input.sharing || "configuration-required" === input.sharing || "disabled" === input.sharing || "unsupported" === input.sharing || _a._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".sharing",
+        expected: "(\"approval-required\" | \"available\" | \"configuration-required\" | \"disabled\" | \"unsupported\")",
+        value: input.sharing
+    }, _errorFactory)) && ("approval-required" === input.inboundShare || "available" === input.inboundShare || "configuration-required" === input.inboundShare || "disabled" === input.inboundShare || "unsupported" === input.inboundShare || _a._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".inboundShare",
+        expected: "(\"approval-required\" | \"available\" | \"configuration-required\" | \"disabled\" | \"unsupported\")",
+        value: input.inboundShare
+    }, _errorFactory)) && ("approval-required" === input.notifications || "available" === input.notifications || "configuration-required" === input.notifications || "disabled" === input.notifications || "unsupported" === input.notifications || _a._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".notifications",
+        expected: "(\"approval-required\" | \"available\" | \"configuration-required\" | \"disabled\" | \"unsupported\")",
+        value: input.notifications
+    }, _errorFactory)) && ("fullscreen" === input.presentationMode || "inline-expanded" === input.presentationMode || _a._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".presentationMode",
+        expected: "(\"fullscreen\" | \"inline-expanded\")",
+        value: input.presentationMode
+    }, _errorFactory));
+    const _ao7 = (input, _path, _exceptionable = true) => ("boolean" === typeof input.externalPaymentAllowed || _a._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".externalPaymentAllowed",
         expected: "boolean",
@@ -376,7 +440,7 @@ export const assertEffectiveTargetConfigMatrix = (() => {
         expected: "boolean",
         value: input.requiresAitReview
     }, _errorFactory));
-    const _ao7 = (input, _path, _exceptionable = true) => ("string" === typeof input.targetConfig || _a._assertGuard(_exceptionable, {
+    const _ao8 = (input, _path, _exceptionable = true) => ("string" === typeof input.targetConfig || _a._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".targetConfig",
         expected: "string",
@@ -402,7 +466,7 @@ export const assertEffectiveTargetConfigMatrix = (() => {
         expected: "(string | undefined)",
         value: input.platformAdapter
     }, _errorFactory));
-    const _ao8 = (input, _path, _exceptionable = true) => _ap1(input, _path, true && _exceptionable) && ((Array.isArray(input.products) || _a._assertGuard(_exceptionable, {
+    const _ao9 = (input, _path, _exceptionable = true) => _ap1(input, _path, true && _exceptionable) && ((Array.isArray(input.products) || _a._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".products",
         expected: "ReadonlyArray<EffectiveProductConfig>",
@@ -412,7 +476,7 @@ export const assertEffectiveTargetConfigMatrix = (() => {
         path: _path + ".products[" + _index3 + "]",
         expected: "EffectiveProductConfig",
         value: elem
-    }, _errorFactory)) && _ao9(elem, _path + ".products[" + _index3 + "]", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+    }, _errorFactory)) && _ao10(elem, _path + ".products[" + _index3 + "]", true && _exceptionable) || _a._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".products[" + _index3 + "]",
         expected: "EffectiveProductConfig",
@@ -423,37 +487,11 @@ export const assertEffectiveTargetConfigMatrix = (() => {
         expected: "ReadonlyArray<EffectiveProductConfig>",
         value: input.products
     }, _errorFactory));
-    const _ao9 = (input, _path, _exceptionable = true) => ("COINS_100" === input.id || "COINS_500" === input.id || "REMOVE_ADS" === input.id || _a._assertGuard(_exceptionable, {
-        method: "typia.createAssert",
-        path: _path + ".id",
-        expected: "(\"COINS_100\" | \"COINS_500\" | \"REMOVE_ADS\")",
-        value: input.id
-    }, _errorFactory)) && ("consumable" === input.type || "non_consumable" === input.type || "subscription" === input.type || _a._assertGuard(_exceptionable, {
-        method: "typia.createAssert",
-        path: _path + ".type",
-        expected: "(\"consumable\" | \"non_consumable\" | \"subscription\")",
-        value: input.type
-    }, _errorFactory)) && (("object" === typeof input.grant && null !== input.grant || _a._assertGuard(_exceptionable, {
-        method: "typia.createAssert",
-        path: _path + ".grant",
-        expected: _ae0,
-        value: input.grant
-    }, _errorFactory)) && _au0(input.grant, _path + ".grant", true && _exceptionable) || _a._assertGuard(_exceptionable, {
-        method: "typia.createAssert",
-        path: _path + ".grant",
-        expected: _ae0,
-        value: input.grant
-    }, _errorFactory)) && _ap5(input, _path, true && _exceptionable) && _ap6(input, _path, true && _exceptionable) && (undefined === input.platformProductId || "string" === typeof input.platformProductId || _a._assertGuard(_exceptionable, {
-        method: "typia.createAssert",
-        path: _path + ".platformProductId",
-        expected: "(string | undefined)",
-        value: input.platformProductId
-    }, _errorFactory));
     const _au0 = (input, _path, _exceptionable = true) => (() => {
         if ("currency" === input.type)
-            return _ao10(input, _path, true && _exceptionable);
-        else if ("entitlement" === input.type)
             return _ao11(input, _path, true && _exceptionable);
+        else if ("entitlement" === input.type)
+            return _ao12(input, _path, true && _exceptionable);
         else
             return _a._assertGuard(_exceptionable, {
                 method: "typia.createAssert",
@@ -464,9 +502,9 @@ export const assertEffectiveTargetConfigMatrix = (() => {
     })();
     const _au1 = (input, _path, _exceptionable = true) => (() => {
         if ("continue" === input.type)
-            return _ao14(input, _path, true && _exceptionable);
-        else if ("currency" === input.type)
             return _ao15(input, _path, true && _exceptionable);
+        else if ("currency" === input.type)
+            return _ao16(input, _path, true && _exceptionable);
         else
             return _a._assertGuard(_exceptionable, {
                 method: "typia.createAssert",
@@ -482,37 +520,38 @@ export const assertEffectiveTargetConfigMatrix = (() => {
             return true;
         return "object" === typeof value && null !== value && _io2(value);
     });
-    const _io10 = input => _ip7(input) && _ip8(input) && _ip9(input);
-    const _io11 = input => "entitlement" === input.type && "string" === typeof input.entitlement;
-    const _io12 = input => _ip2(input) && _ip3(input) && (Array.isArray(input.placements) && input.placements.every(elem => "object" === typeof elem && null !== elem && _io13(elem)));
-    const _io13 = input => ("CONTINUE_AFTER_FAIL" === input.id || "STAGE_END_INTERSTITIAL" === input.id) && ("interstitial" === input.type || "rewarded" === input.type) && (undefined === input.reward || "object" === typeof input.reward && null !== input.reward && _iu1(input.reward)) && ("object" === typeof input.frequencyCap && null !== input.frequencyCap && _io16(input.frequencyCap)) && _ip5(input) && _ip6(input) && (undefined === input.platformPlacementId || "string" === typeof input.platformPlacementId);
-    const _io14 = input => "continue" === input.type && _ip9(input);
-    const _io15 = input => _ip7(input) && _ip9(input) && _ip8(input);
-    const _io16 = input => "number" === typeof input.cooldownSeconds && (undefined === input.maxPerSession || "number" === typeof input.maxPerSession) && (undefined === input.minStageInterval || "number" === typeof input.minStageInterval);
-    const _io17 = input => "boolean" === typeof input.native && _ip5(input) && ("available" === input.reason || "capability-unsupported" === input.reason || "target-disabled" === input.reason) && (undefined === input.defaultLeaderboardId || "string" === typeof input.defaultLeaderboardId);
-    const _io18 = input => ("local" === input.support || "native" === input.support || "none" === input.support) && _ip5(input);
-    const _io19 = input => _ip5(input);
-    const _io2 = input => _ip0(input) && "string" === typeof input.target && ("apps-in-toss" === input.runtime || "capacitor-android" === input.runtime || "capacitor-ios" === input.runtime || "devvit-web" === input.runtime || "microsoft-store-pwa" === input.runtime || "web-preview" === input.runtime) && ("object" === typeof input.release && null !== input.release && _io3(input.release)) && ("object" === typeof input.features && null !== input.features && _io4(input.features)) && ("object" === typeof input.capabilities && null !== input.capabilities && _io5(input.capabilities)) && ("object" === typeof input.policy && null !== input.policy && _io6(input.policy)) && ("object" === typeof input.sources && null !== input.sources && _io7(input.sources)) && ("object" === typeof input.monetization && null !== input.monetization && _io8(input.monetization)) && ("object" === typeof input.ads && null !== input.ads && _io12(input.ads)) && ("object" === typeof input.leaderboard && null !== input.leaderboard && _io17(input.leaderboard)) && ("object" === typeof input.storage && null !== input.storage && _io18(input.storage)) && ("object" === typeof input.localization && null !== input.localization && _io19(input.localization));
+    const _io10 = input => _ip5(input) && ("consumable" === input.type || "non_consumable" === input.type || "subscription" === input.type) && ("object" === typeof input.grant && null !== input.grant && _iu0(input.grant)) && _ip6(input) && _ip7(input) && (undefined === input.platformProductId || "string" === typeof input.platformProductId);
+    const _io11 = input => _ip8(input) && _ip9(input) && _ip10(input);
+    const _io12 = input => "entitlement" === input.type && "string" === typeof input.entitlement;
+    const _io13 = input => _ip2(input) && _ip3(input) && (Array.isArray(input.placements) && input.placements.every(elem => "object" === typeof elem && null !== elem && _io14(elem)));
+    const _io14 = input => _ip5(input) && ("interstitial" === input.type || "rewarded" === input.type) && (undefined === input.reward || "object" === typeof input.reward && null !== input.reward && _iu1(input.reward)) && ("object" === typeof input.frequencyCap && null !== input.frequencyCap && _io17(input.frequencyCap)) && _ip6(input) && _ip7(input) && (undefined === input.platformPlacementId || "string" === typeof input.platformPlacementId);
+    const _io15 = input => "continue" === input.type && _ip10(input);
+    const _io16 = input => _ip8(input) && _ip10(input) && _ip9(input);
+    const _io17 = input => "number" === typeof input.cooldownSeconds && (undefined === input.maxPerSession || "number" === typeof input.maxPerSession) && (undefined === input.minStageInterval || "number" === typeof input.minStageInterval);
+    const _io18 = input => "boolean" === typeof input.native && _ip6(input) && ("available" === input.reason || "capability-unsupported" === input.reason || "target-disabled" === input.reason) && (undefined === input.defaultLeaderboardId || "string" === typeof input.defaultLeaderboardId);
+    const _io19 = input => ("local" === input.support || "native" === input.support || "none" === input.support) && _ip6(input);
+    const _io2 = input => _ip0(input) && "string" === typeof input.target && ("apps-in-toss" === input.runtime || "capacitor-android" === input.runtime || "capacitor-ios" === input.runtime || "devvit-web" === input.runtime || "microsoft-store-pwa" === input.runtime || "web-preview" === input.runtime) && ("object" === typeof input.release && null !== input.release && _io3(input.release)) && ("object" === typeof input.features && null !== input.features && _io4(input.features)) && ("object" === typeof input.capabilities && null !== input.capabilities && _io5(input.capabilities)) && ("object" === typeof input.integrations && null !== input.integrations && _io6(input.integrations)) && ("object" === typeof input.policy && null !== input.policy && _io7(input.policy)) && ("object" === typeof input.sources && null !== input.sources && _io8(input.sources)) && ("object" === typeof input.monetization && null !== input.monetization && _io9(input.monetization)) && ("object" === typeof input.ads && null !== input.ads && _io13(input.ads)) && ("object" === typeof input.leaderboard && null !== input.leaderboard && _io18(input.leaderboard)) && ("object" === typeof input.storage && null !== input.storage && _io19(input.storage)) && ("object" === typeof input.localization && null !== input.localization && _io20(input.localization));
+    const _io20 = input => _ip6(input);
     const _io3 = input => "app-store" === input.profile || "apps-in-toss" === input.profile || "devvit" === input.profile || "google-play" === input.profile || "microsoft-store" === input.profile || "web-preview" === input.profile;
     const _io4 = input => _ip1(input) && _ip2(input) && _ip3(input) && "boolean" === typeof input.leaderboard && _ip4(input);
     const _io5 = input => ("local" === input.storage || "native" === input.storage || "none" === input.storage) && _ip4(input);
-    const _io6 = input => "boolean" === typeof input.externalPaymentAllowed && "boolean" === typeof input.remoteExecutableCodeAllowed && "boolean" === typeof input.installOtherAppCTAAllowed && "boolean" === typeof input.requiresStoreReview && "boolean" === typeof input.requiresAitReview;
-    const _io7 = input => "string" === typeof input.targetConfig && "string" === typeof input.productCatalog && "string" === typeof input.adPlacements && (undefined === input.platformTargetKind || "string" === typeof input.platformTargetKind) && (undefined === input.platformAdapter || "string" === typeof input.platformAdapter);
-    const _io8 = input => _ip1(input) && (Array.isArray(input.products) && input.products.every(elem => "object" === typeof elem && null !== elem && _io9(elem)));
-    const _io9 = input => ("COINS_100" === input.id || "COINS_500" === input.id || "REMOVE_ADS" === input.id) && ("consumable" === input.type || "non_consumable" === input.type || "subscription" === input.type) && ("object" === typeof input.grant && null !== input.grant && _iu0(input.grant)) && _ip5(input) && _ip6(input) && (undefined === input.platformProductId || "string" === typeof input.platformProductId);
+    const _io6 = input => ("approval-required" === input.identityUpgrade || "available" === input.identityUpgrade || "configuration-required" === input.identityUpgrade || "disabled" === input.identityUpgrade || "unsupported" === input.identityUpgrade) && ("approval-required" === input.presentation || "available" === input.presentation || "configuration-required" === input.presentation || "disabled" === input.presentation || "unsupported" === input.presentation) && ("approval-required" === input.sharing || "available" === input.sharing || "configuration-required" === input.sharing || "disabled" === input.sharing || "unsupported" === input.sharing) && ("approval-required" === input.inboundShare || "available" === input.inboundShare || "configuration-required" === input.inboundShare || "disabled" === input.inboundShare || "unsupported" === input.inboundShare) && ("approval-required" === input.notifications || "available" === input.notifications || "configuration-required" === input.notifications || "disabled" === input.notifications || "unsupported" === input.notifications) && ("fullscreen" === input.presentationMode || "inline-expanded" === input.presentationMode);
+    const _io7 = input => "boolean" === typeof input.externalPaymentAllowed && "boolean" === typeof input.remoteExecutableCodeAllowed && "boolean" === typeof input.installOtherAppCTAAllowed && "boolean" === typeof input.requiresStoreReview && "boolean" === typeof input.requiresAitReview;
+    const _io8 = input => "string" === typeof input.targetConfig && "string" === typeof input.productCatalog && "string" === typeof input.adPlacements && (undefined === input.platformTargetKind || "string" === typeof input.platformTargetKind) && (undefined === input.platformAdapter || "string" === typeof input.platformAdapter);
+    const _io9 = input => _ip1(input) && (Array.isArray(input.products) && input.products.every(elem => "object" === typeof elem && null !== elem && _io10(elem)));
     const _iu0 = input => (() => {
         if ("currency" === input.type)
-            return _io10(input);
-        else if ("entitlement" === input.type)
             return _io11(input);
+        else if ("entitlement" === input.type)
+            return _io12(input);
         else
             return false;
     })();
     const _iu1 = input => (() => {
         if ("continue" === input.type)
-            return _io14(input);
-        else if ("currency" === input.type)
             return _io15(input);
+        else if ("currency" === input.type)
+            return _io16(input);
         else
             return false;
     })();
@@ -662,6 +701,16 @@ export const assertTargetConfigMatrix = (() => {
         path: _path + ".policy",
         expected: "TargetPolicyRestrictions",
         value: input.policy
+    }, _errorFactory)) && (undefined === input.integrations || ("object" === typeof input.integrations && null !== input.integrations || _a._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".integrations",
+        expected: "(TargetIntegrationConfig | undefined)",
+        value: input.integrations
+    }, _errorFactory)) && _ao9(input.integrations, _path + ".integrations", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".integrations",
+        expected: "(TargetIntegrationConfig | undefined)",
+        value: input.integrations
     }, _errorFactory));
     const _ao3 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && _ap1(input, _path, true && _exceptionable) && _ap2(input, _path, true && _exceptionable) && ("boolean" === typeof input.leaderboard || _a._assertGuard(_exceptionable, {
         method: "typia.createAssert",
@@ -714,6 +763,37 @@ export const assertTargetConfigMatrix = (() => {
         expected: "boolean",
         value: input.requiresAitReview
     }, _errorFactory));
+    const _ao9 = (input, _path, _exceptionable = true) => ("approval-required" === input.identityUpgrade || "available" === input.identityUpgrade || "configuration-required" === input.identityUpgrade || "disabled" === input.identityUpgrade || "unsupported" === input.identityUpgrade || _a._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".identityUpgrade",
+        expected: "(\"approval-required\" | \"available\" | \"configuration-required\" | \"disabled\" | \"unsupported\")",
+        value: input.identityUpgrade
+    }, _errorFactory)) && ("approval-required" === input.presentation || "available" === input.presentation || "configuration-required" === input.presentation || "disabled" === input.presentation || "unsupported" === input.presentation || _a._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".presentation",
+        expected: "(\"approval-required\" | \"available\" | \"configuration-required\" | \"disabled\" | \"unsupported\")",
+        value: input.presentation
+    }, _errorFactory)) && ("approval-required" === input.sharing || "available" === input.sharing || "configuration-required" === input.sharing || "disabled" === input.sharing || "unsupported" === input.sharing || _a._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".sharing",
+        expected: "(\"approval-required\" | \"available\" | \"configuration-required\" | \"disabled\" | \"unsupported\")",
+        value: input.sharing
+    }, _errorFactory)) && ("approval-required" === input.inboundShare || "available" === input.inboundShare || "configuration-required" === input.inboundShare || "disabled" === input.inboundShare || "unsupported" === input.inboundShare || _a._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".inboundShare",
+        expected: "(\"approval-required\" | \"available\" | \"configuration-required\" | \"disabled\" | \"unsupported\")",
+        value: input.inboundShare
+    }, _errorFactory)) && ("approval-required" === input.notifications || "available" === input.notifications || "configuration-required" === input.notifications || "disabled" === input.notifications || "unsupported" === input.notifications || _a._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".notifications",
+        expected: "(\"approval-required\" | \"available\" | \"configuration-required\" | \"disabled\" | \"unsupported\")",
+        value: input.notifications
+    }, _errorFactory)) && ("fullscreen" === input.presentationMode || "inline-expanded" === input.presentationMode || _a._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".presentationMode",
+        expected: "(\"fullscreen\" | \"inline-expanded\")",
+        value: input.presentationMode
+    }, _errorFactory));
     const _io0 = input => "string" === typeof input.version && ("object" === typeof input.targets && null !== input.targets && false === Array.isArray(input.targets) && _io1(input.targets));
     const _io1 = input => Object.keys(input).every(key => {
         const value = input[key];
@@ -721,13 +801,14 @@ export const assertTargetConfigMatrix = (() => {
             return true;
         return "object" === typeof value && null !== value && _io2(value);
     });
-    const _io2 = input => ("apps-in-toss" === input.runtime || "capacitor-android" === input.runtime || "capacitor-ios" === input.runtime || "devvit-web" === input.runtime || "microsoft-store-pwa" === input.runtime || "web-preview" === input.runtime) && ("object" === typeof input.features && null !== input.features && _io3(input.features)) && ("object" === typeof input.capabilities && null !== input.capabilities && _io4(input.capabilities)) && ("object" === typeof input.monetization && null !== input.monetization && _io5(input.monetization)) && ("object" === typeof input.leaderboard && null !== input.leaderboard && _io6(input.leaderboard)) && ("object" === typeof input.release && null !== input.release && _io7(input.release)) && ("object" === typeof input.policy && null !== input.policy && _io8(input.policy));
+    const _io2 = input => ("apps-in-toss" === input.runtime || "capacitor-android" === input.runtime || "capacitor-ios" === input.runtime || "devvit-web" === input.runtime || "microsoft-store-pwa" === input.runtime || "web-preview" === input.runtime) && ("object" === typeof input.features && null !== input.features && _io3(input.features)) && ("object" === typeof input.capabilities && null !== input.capabilities && _io4(input.capabilities)) && ("object" === typeof input.monetization && null !== input.monetization && _io5(input.monetization)) && ("object" === typeof input.leaderboard && null !== input.leaderboard && _io6(input.leaderboard)) && ("object" === typeof input.release && null !== input.release && _io7(input.release)) && ("object" === typeof input.policy && null !== input.policy && _io8(input.policy)) && (undefined === input.integrations || "object" === typeof input.integrations && null !== input.integrations && _io9(input.integrations));
     const _io3 = input => _ip0(input) && _ip1(input) && _ip2(input) && "boolean" === typeof input.leaderboard && _ip3(input);
     const _io4 = input => ("local" === input.storage || "native" === input.storage || "none" === input.storage) && _ip3(input);
     const _io5 = input => _ip0(input) && _ip1(input) && _ip2(input);
     const _io6 = input => "boolean" === typeof input.native;
     const _io7 = input => "app-store" === input.profile || "apps-in-toss" === input.profile || "devvit" === input.profile || "google-play" === input.profile || "microsoft-store" === input.profile || "web-preview" === input.profile;
     const _io8 = input => "boolean" === typeof input.externalPaymentAllowed && "boolean" === typeof input.remoteExecutableCodeAllowed && "boolean" === typeof input.installOtherAppCTAAllowed && "boolean" === typeof input.requiresStoreReview && "boolean" === typeof input.requiresAitReview;
+    const _io9 = input => ("approval-required" === input.identityUpgrade || "available" === input.identityUpgrade || "configuration-required" === input.identityUpgrade || "disabled" === input.identityUpgrade || "unsupported" === input.identityUpgrade) && ("approval-required" === input.presentation || "available" === input.presentation || "configuration-required" === input.presentation || "disabled" === input.presentation || "unsupported" === input.presentation) && ("approval-required" === input.sharing || "available" === input.sharing || "configuration-required" === input.sharing || "disabled" === input.sharing || "unsupported" === input.sharing) && ("approval-required" === input.inboundShare || "available" === input.inboundShare || "configuration-required" === input.inboundShare || "disabled" === input.inboundShare || "unsupported" === input.inboundShare) && ("approval-required" === input.notifications || "available" === input.notifications || "configuration-required" === input.notifications || "disabled" === input.notifications || "unsupported" === input.notifications) && ("fullscreen" === input.presentationMode || "inline-expanded" === input.presentationMode);
     const __is = input => "object" === typeof input && null !== input && _io0(input);
     let _errorFactory;
     return (input, errorFactory) => {

package/dist/runtime.d.ts

@@ -1,11 +1,22 @@
 import type { PlatformCapabilities, PlatformGateway } from '@mpgd/platform';
-import type { EffectiveTargetConfig } from './effective';
+import type { EffectiveTargetConfig } from './effective.js';
 export type PlatformFeature = 'iap' | 'rewardedAds' | 'interstitialAds' | 'leaderboard' | 'localization';
 export type AdPlacementType = 'rewarded' | 'interstitial';
 type PlatformConfigTarget = PlatformGateway['target'];
 export type TargetRuntimeKind = 'web-preview' | 'microsoft-store-pwa' | 'capacitor-android' | 'capacitor-ios' | 'apps-in-toss' | 'devvit-web';
 export type ReleaseProfile = 'web-preview' | 'microsoft-store' | 'google-play' | 'app-store' | 'apps-in-toss' | 'devvit';
 export type StorageSupport = 'local' | 'native' | 'none';
+export type TargetIntegration = 'identityUpgrade' | 'presentation' | 'sharing' | 'inboundShare' | 'notifications';
+export type IntegrationAvailabilityState = 'available' | 'disabled' | 'approval-required' | 'configuration-required' | 'unsupported';
+export type PresentationMode = 'fullscreen' | 'inline-expanded';
+export interface TargetIntegrationConfig {
+  readonly identityUpgrade: IntegrationAvailabilityState;
+  readonly presentation: IntegrationAvailabilityState;
+  readonly sharing: IntegrationAvailabilityState;
+  readonly inboundShare: IntegrationAvailabilityState;
+  readonly notifications: IntegrationAvailabilityState;
+  readonly presentationMode: PresentationMode;
+}
 export interface TargetFeatureConfig {
   readonly iap: boolean;
   readonly rewardedAds: boolean;
@@ -43,6 +54,7 @@ export interface TargetConfig {
   readonly leaderboard: TargetLeaderboardConfig;
   readonly release: TargetReleaseConfig;
   readonly policy: TargetPolicyRestrictions;
+  readonly integrations?: TargetIntegrationConfig;
 }
 export interface TargetConfigMatrix {
   readonly version: string;
@@ -66,13 +78,21 @@ export interface AdPlacementAvailability {
   readonly enabled: boolean;
   readonly reason: FeatureAvailabilityReason;
 }
+export interface IntegrationAvailability {
+  readonly integration: TargetIntegration;
+  readonly state: IntegrationAvailabilityState;
+  readonly configuredState: IntegrationAvailabilityState;
+  readonly adapterSupported: boolean;
+}
 export interface TargetRuntimeSnapshot {
   readonly target: PlatformConfigTarget;
   readonly configTarget: string;
   readonly config: TargetConfig;
   readonly effectiveConfig?: EffectiveTargetConfig;
+  readonly presentationMode: PresentationMode;
   readonly capabilities: PlatformCapabilities;
   readonly features: Record<PlatformFeature, FeatureAvailability>;
+  readonly integrations: Record<TargetIntegration, IntegrationAvailability>;
   readonly adPlacements: readonly AdPlacementAvailability[];
 }
 export interface TargetAvailabilityOptions {
@@ -88,11 +108,22 @@ export interface TargetConfiguredGateway extends PlatformGateway {
   getTargetRuntime(): Promise<TargetRuntimeSnapshot>;
 }
 export declare const platformFeatures: readonly ["iap", "rewardedAds", "interstitialAds", "leaderboard", "localization"];
+export declare const targetIntegrations: readonly ["identityUpgrade", "presentation", "sharing", "inboundShare", "notifications"];
+export declare const defaultTargetIntegrationConfig: {
+  readonly identityUpgrade: 'disabled';
+  readonly presentation: 'disabled';
+  readonly sharing: 'disabled';
+  readonly inboundShare: 'disabled';
+  readonly notifications: 'unsupported';
+  readonly presentationMode: 'fullscreen';
+};
+export declare function normalizeTargetIntegrationConfig(config: Partial<TargetIntegrationConfig> | undefined): TargetIntegrationConfig;
 export declare function targetConfigKeyForPlatform(target: PlatformConfigTarget): string;
 export declare function getTargetConfig(matrix: TargetConfigMatrix, target: PlatformConfigTarget | string): TargetConfig;
 export declare function isPlatformFeatureEnabled(config: TargetConfig, feature: PlatformFeature): boolean;
 export declare function applyTargetConfigToCapabilities(capabilities: PlatformCapabilities, config: TargetConfig): PlatformCapabilities;
 export declare function getFeatureAvailability(feature: PlatformFeature, config: TargetConfig, capabilities: PlatformCapabilities): FeatureAvailability;
+export declare function getIntegrationAvailability(integration: TargetIntegration, config: TargetConfig, gateway?: PlatformGateway): IntegrationAvailability;
 export declare function createTargetRuntimeSnapshot(input: {
   readonly target: PlatformConfigTarget;
   readonly configTarget?: string;
@@ -100,6 +131,7 @@ export declare function createTargetRuntimeSnapshot(input: {
   readonly effectiveConfig?: EffectiveTargetConfig;
   readonly capabilities: PlatformCapabilities;
   readonly adPlacements?: readonly AdPlacementDefinition[];
+  readonly gateway?: PlatformGateway;
 }): TargetRuntimeSnapshot;
 export declare function withTargetAvailability(gateway: PlatformGateway, config: TargetConfig, options?: TargetAvailabilityOptions): TargetConfiguredGateway;
 export declare function isTargetConfiguredGateway(gateway: PlatformGateway): gateway is TargetConfiguredGateway;

package/dist/runtime.js

@@ -5,6 +5,41 @@ export const platformFeatures = [
     'leaderboard',
     'localization',
 ];
+export const targetIntegrations = [
+    'identityUpgrade',
+    'presentation',
+    'sharing',
+    'inboundShare',
+    'notifications',
+];
+export const defaultTargetIntegrationConfig = {
+    identityUpgrade: 'disabled',
+    presentation: 'disabled',
+    sharing: 'disabled',
+    inboundShare: 'disabled',
+    notifications: 'unsupported',
+    presentationMode: 'fullscreen',
+};
+const integrationAvailabilityStates = new Set([
+    'available',
+    'disabled',
+    'approval-required',
+    'configuration-required',
+    'unsupported',
+]);
+export function normalizeTargetIntegrationConfig(config) {
+    if (config === undefined) {
+        return defaultTargetIntegrationConfig;
+    }
+    return {
+        identityUpgrade: normalizeIntegrationAvailabilityState(config.identityUpgrade, defaultTargetIntegrationConfig.identityUpgrade),
+        presentation: normalizeIntegrationAvailabilityState(config.presentation, defaultTargetIntegrationConfig.presentation),
+        sharing: normalizeIntegrationAvailabilityState(config.sharing, defaultTargetIntegrationConfig.sharing),
+        inboundShare: normalizeIntegrationAvailabilityState(config.inboundShare, defaultTargetIntegrationConfig.inboundShare),
+        notifications: normalizeIntegrationAvailabilityState(config.notifications, defaultTargetIntegrationConfig.notifications),
+        presentationMode: normalizePresentationMode(config.presentationMode),
+    };
+}
 export function targetConfigKeyForPlatform(target) {
     return target === 'browser' ? 'web-preview' : target;
 }
@@ -46,6 +81,10 @@ export function getFeatureAvailability(feature, config, capabilities) {
                 : 'target-disabled',
     };
 }
+export function getIntegrationAvailability(integration, config, gateway) {
+    const integrations = normalizeTargetIntegrationConfig(config.integrations);
+    return createIntegrationAvailability(integration, integrations[integration], gateway);
+}
 export function createTargetRuntimeSnapshot(input) {
     const configTarget = input.configTarget ?? targetConfigKeyForPlatform(input.target);
     const features = {
@@ -55,13 +94,21 @@ export function createTargetRuntimeSnapshot(input) {
         leaderboard: getFeatureAvailability('leaderboard', input.config, input.capabilities),
         localization: getFeatureAvailability('localization', input.config, input.capabilities),
     };
+    const integrationConfig = normalizeTargetIntegrationConfig(input.config.integrations);
+    const integrationEntries = targetIntegrations.map((integration) => {
+        const availability = createIntegrationAvailability(integration, integrationConfig[integration], input.gateway);
+        return [integration, availability];
+    });
+    const integrations = Object.fromEntries(integrationEntries);
     return {
         target: input.target,
         configTarget,
         config: input.config,
         ...(input.effectiveConfig === undefined ? {} : { effectiveConfig: input.effectiveConfig }),
+        presentationMode: integrationConfig.presentationMode,
         capabilities: input.capabilities,
         features,
+        integrations,
         adPlacements: (input.adPlacements ?? []).map((placement) => {
             const feature = placement.type === 'rewarded' ? 'rewardedAds' : 'interstitialAds';
             const availability = features[feature];
@@ -76,6 +123,36 @@ export function createTargetRuntimeSnapshot(input) {
 }
 export function withTargetAvailability(gateway, config, options = {}) {
     const configTarget = options.configTarget ?? targetConfigKeyForPlatform(gateway.target);
+    const { identity: gatewayIdentity, presentation: gatewayPresentation, sharing: gatewaySharing, notifications: gatewayNotifications, ...gatewayWithoutIntegrations } = gateway;
+    const integrations = normalizeTargetIntegrationConfig(config.integrations);
+    const isIntegrationAvailable = (integration) => (createIntegrationAvailability(integration, integrations[integration], gateway).state
+        === 'available');
+    const identityUpgradeAvailable = isIntegrationAvailable('identityUpgrade');
+    const presentationAvailable = isIntegrationAvailable('presentation');
+    const sharingAvailable = isIntegrationAvailable('sharing');
+    const inboundShareAvailable = isIntegrationAvailable('inboundShare');
+    const notificationsAvailable = isIntegrationAvailable('notifications');
+    const getIdentitySession = gatewayIdentity.getSession?.bind(gatewayIdentity);
+    const requestIdentityUpgrade = gatewayIdentity.requestUpgrade?.bind(gatewayIdentity);
+    const shareOutbound = gatewaySharing?.share?.bind(gatewaySharing);
+    const readInboundShare = gatewaySharing?.readInboundShare?.bind(gatewaySharing);
+    const exposeOutboundShare = sharingAvailable && shareOutbound !== undefined;
+    const exposeInboundShare = inboundShareAvailable && readInboundShare !== undefined;
+    const identity = {
+        getPlayer: gatewayIdentity.getPlayer.bind(gatewayIdentity),
+        ...(getIdentitySession === undefined ? {} : { getSession: getIdentitySession }),
+        ...(!identityUpgradeAvailable || requestIdentityUpgrade === undefined
+            ? {}
+            : { requestUpgrade: requestIdentityUpgrade }),
+    };
+    const presentation = presentationAvailable ? gatewayPresentation : undefined;
+    const sharing = !exposeOutboundShare && !exposeInboundShare
+        ? undefined
+        : {
+            ...(exposeOutboundShare ? { share: shareOutbound } : {}),
+            ...(exposeInboundShare ? { readInboundShare } : {}),
+        };
+    const notifications = notificationsAvailable ? gatewayNotifications : undefined;
     const isAdPlacementAllowed = (placementId, expectedType) => {
         const actualType = options.resolveAdPlacementType?.(placementId);
         if (actualType !== undefined && actualType !== expectedType) {
@@ -96,7 +173,11 @@ export function withTargetAvailability(gateway, config, options = {}) {
         return config.features.rewardedAds || config.features.interstitialAds;
     };
     return {
-        ...gateway,
+        ...gatewayWithoutIntegrations,
+        identity,
+        ...(presentation === undefined ? {} : { presentation }),
+        ...(sharing === undefined ? {} : { sharing }),
+        ...(notifications === undefined ? {} : { notifications }),
         configTarget,
         targetConfig: config,
         ...(options.effectiveConfig === undefined
@@ -112,6 +193,7 @@ export function withTargetAvailability(gateway, config, options = {}) {
                     : { effectiveConfig: options.effectiveConfig }),
                 capabilities: applyTargetConfigToCapabilities(await gateway.getCapabilities(), config),
                 adPlacements: options.adPlacements ?? [],
+                gateway,
             });
         },
         async getCapabilities() {
@@ -192,3 +274,43 @@ function isFeatureCapabilitySupported(feature, capabilities) {
             return capabilities.localizedContent;
     }
 }
+function isIntegrationAdapterSupported(integration, gateway) {
+    if (gateway === undefined) {
+        return false;
+    }
+    switch (integration) {
+        case 'identityUpgrade':
+            return typeof gateway.identity.requestUpgrade === 'function';
+        case 'presentation':
+            return (typeof gateway.presentation?.getLaunchIntent === 'function'
+                && typeof gateway.presentation?.requestGameSurface === 'function');
+        case 'sharing':
+            return typeof gateway.sharing?.share === 'function';
+        case 'inboundShare':
+            return typeof gateway.sharing?.readInboundShare === 'function';
+        case 'notifications':
+            return (typeof gateway.notifications?.getStatus === 'function'
+                && typeof gateway.notifications?.requestSubscription === 'function');
+    }
+}
+function createIntegrationAvailability(integration, configuredState, gateway) {
+    const adapterSupported = isIntegrationAdapterSupported(integration, gateway);
+    return {
+        integration,
+        state: adapterSupported ? configuredState : 'unsupported',
+        configuredState,
+        adapterSupported,
+    };
+}
+function normalizeIntegrationAvailabilityState(input, fallback) {
+    if (input !== undefined && integrationAvailabilityStates.has(input)) {
+        return input;
+    }
+    return fallback;
+}
+function normalizePresentationMode(input) {
+    if (input === 'inline-expanded' || input === 'fullscreen') {
+        return input;
+    }
+    return defaultTargetIntegrationConfig.presentationMode;
+}

package/dist/viewport.d.ts

@@ -1,5 +1,7 @@
-import type { TargetConfig, TargetRuntimeKind } from './runtime';
+import type { TargetConfig, TargetRuntimeKind } from './runtime.js';
 export type TargetViewportOrientation = 'portrait' | 'landscape';
+export type TargetViewportOrientationPolicyMode = 'responsive' | 'prefer-landscape' | 'prefer-portrait' | 'lock-landscape' | 'lock-portrait';
+export type TargetViewportOrientationMismatchBehavior = 'continue' | 'letterbox' | 'show-rotate-prompt';
 export type TargetViewportSizeClass = 'compact' | 'medium' | 'expanded';
 export type TargetViewportShell = 'browser' | 'mobile-webview' | 'embedded-webview';
 export type TargetViewportMeasurementSource = 'container' | 'visual-viewport' | 'window' | 'unknown';
@@ -14,6 +16,7 @@ export interface TargetViewportInput {
   readonly height: number;
   readonly runtime?: TargetRuntimeKind;
   readonly source?: TargetViewportMeasurementSource;
+  readonly orientationPolicy?: TargetViewportOrientationPolicy;
 }
 export interface TargetViewportLayout {
   readonly width: number;
@@ -31,17 +34,36 @@ export interface TargetViewportRecommendation {
   readonly secondaryPanels: TargetViewportPanelPlacement;
   readonly safeAreaAware: boolean;
 }
+export interface TargetViewportOrientationPolicy {
+  readonly mode: TargetViewportOrientationPolicyMode;
+  readonly mismatchBehavior?: TargetViewportOrientationMismatchBehavior;
+}
+export interface TargetViewportOrientationPlan {
+  readonly mode: TargetViewportOrientationPolicyMode;
+  readonly preferredOrientation?: TargetViewportOrientation;
+  readonly lockedOrientation?: TargetViewportOrientation;
+  readonly mismatchBehavior: TargetViewportOrientationMismatchBehavior;
+  readonly isMismatch: boolean;
+  readonly shouldLetterbox: boolean;
+  readonly shouldShowRotatePrompt: boolean;
+}
 export interface TargetViewportPlan {
   readonly layout: TargetViewportLayout;
   readonly recommendation: TargetViewportRecommendation;
+  readonly orientation: TargetViewportOrientationPlan;
 }
 export declare const defaultTargetViewportBreakpoints: {
   readonly compactMaxWidth: 599;
   readonly expandedMinWidth: 900;
 };
+export declare const defaultTargetViewportOrientationPolicy: {
+  readonly mode: 'responsive';
+  readonly mismatchBehavior: 'continue';
+};
 export declare function targetViewportShellForRuntime(runtime: TargetRuntimeKind): TargetViewportShell;
 export declare function targetViewportShellForConfig(config: Pick<TargetConfig, 'runtime'>): TargetViewportShell;
 export declare function resolveTargetViewportLayout(input: TargetViewportInput, breakpoints?: TargetViewportBreakpoints): TargetViewportLayout;
 export declare function resolveTargetViewportSizeClass(width: number, breakpoints?: TargetViewportBreakpoints): TargetViewportSizeClass;
 export declare function resolveTargetViewportRecommendation(layout: TargetViewportLayout): TargetViewportRecommendation;
+export declare function resolveTargetViewportOrientationPlan(layout: Pick<TargetViewportLayout, 'orientation'>, policy?: TargetViewportOrientationPolicy): TargetViewportOrientationPlan;
 export declare function resolveTargetViewportPlan(input: TargetViewportInput, breakpoints?: TargetViewportBreakpoints): TargetViewportPlan;

package/dist/viewport.js

@@ -2,6 +2,37 @@ export const defaultTargetViewportBreakpoints = {
     compactMaxWidth: 599,
     expandedMinWidth: 900,
 };
+export const defaultTargetViewportOrientationPolicy = {
+    mode: 'responsive',
+    mismatchBehavior: 'continue',
+};
+const targetViewportOrientationPolicyModeDescriptors = {
+    responsive: {
+        preferredOrientation: undefined,
+        lockedOrientation: undefined,
+        isLocked: false,
+    },
+    'prefer-landscape': {
+        preferredOrientation: 'landscape',
+        lockedOrientation: undefined,
+        isLocked: false,
+    },
+    'prefer-portrait': {
+        preferredOrientation: 'portrait',
+        lockedOrientation: undefined,
+        isLocked: false,
+    },
+    'lock-landscape': {
+        preferredOrientation: 'landscape',
+        lockedOrientation: 'landscape',
+        isLocked: true,
+    },
+    'lock-portrait': {
+        preferredOrientation: 'portrait',
+        lockedOrientation: 'portrait',
+        isLocked: true,
+    },
+};
 export function targetViewportShellForRuntime(runtime) {
     switch (runtime) {
         case 'capacitor-android':
@@ -51,11 +82,29 @@ export function resolveTargetViewportRecommendation(layout) {
         safeAreaAware: layout.shell !== 'browser' || layout.sizeClass === 'compact' || browserSafeAreaRisk,
     };
 }
+export function resolveTargetViewportOrientationPlan(layout, policy = defaultTargetViewportOrientationPolicy) {
+    const normalizedPolicy = normalizeTargetViewportOrientationPolicy(policy);
+    const descriptor = targetViewportOrientationPolicyModeDescriptors[normalizedPolicy.mode];
+    const preferredOrientation = descriptor.preferredOrientation;
+    const lockedOrientation = descriptor.lockedOrientation;
+    const isMismatch = preferredOrientation !== undefined && layout.orientation !== preferredOrientation;
+    const mismatchBehavior = normalizedPolicy.mismatchBehavior;
+    return {
+        mode: normalizedPolicy.mode,
+        ...(preferredOrientation === undefined ? {} : { preferredOrientation }),
+        ...(lockedOrientation === undefined ? {} : { lockedOrientation }),
+        mismatchBehavior,
+        isMismatch,
+        shouldLetterbox: isMismatch && mismatchBehavior === 'letterbox',
+        shouldShowRotatePrompt: isMismatch && mismatchBehavior === 'show-rotate-prompt',
+    };
+}
 export function resolveTargetViewportPlan(input, breakpoints = defaultTargetViewportBreakpoints) {
     const layout = resolveTargetViewportLayout(input, breakpoints);
     return {
         layout,
         recommendation: resolveTargetViewportRecommendation(layout),
+        orientation: resolveTargetViewportOrientationPlan(layout, input.orientationPolicy),
     };
 }
 function classifyTargetViewportSize(width, breakpoints) {
@@ -76,6 +125,14 @@ function resolveTargetViewportPanelPlacement(layout) {
     }
     return 'side';
 }
+function normalizeTargetViewportOrientationPolicy(policy) {
+    const descriptor = targetViewportOrientationPolicyModeDescriptors[policy.mode];
+    return {
+        mode: policy.mode,
+        mismatchBehavior: policy.mismatchBehavior ??
+            (descriptor.isLocked ? 'show-rotate-prompt' : 'continue'),
+    };
+}
 function normalizeTargetViewportBreakpoints(breakpoints) {
     const compactMaxWidth = normalizeViewportDimension(breakpoints.compactMaxWidth, 'compactMaxWidth');
     const expandedMinWidth = normalizeViewportDimension(breakpoints.expandedMinWidth, 'expandedMinWidth');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpgd/target-config",
-  "version": "0.3.4",
+  "version": "0.5.0",
   "description": "Target-specific platform feature availability and effective config helpers for mpgd.",
   "license": "MIT",
   "repository": {
@@ -37,8 +37,8 @@
   ],
   "dependencies": {
     "typia": "rc",
-    "@mpgd/catalog": "0.3.2",
-    "@mpgd/platform": "0.3.2"
+    "@mpgd/catalog": "0.3.3",
+    "@mpgd/platform": "0.4.0"
   },
   "devDependencies": {
     "ttsc": "0.16.9",

package/targets.json

@@ -1,5 +1,5 @@
 {
-  "version": "2026-07-03",
+  "version": "2026-07-10",
   "targets": {
     "web-preview": {
       "runtime": "web-preview",
@@ -25,6 +25,14 @@
       "release": {
         "profile": "web-preview"
       },
+      "integrations": {
+        "identityUpgrade": "disabled",
+        "presentation": "available",
+        "sharing": "available",
+        "inboundShare": "available",
+        "notifications": "unsupported",
+        "presentationMode": "fullscreen"
+      },
       "policy": {
         "externalPaymentAllowed": false,
         "remoteExecutableCodeAllowed": false,
@@ -57,6 +65,14 @@
       "release": {
         "profile": "microsoft-store"
       },
+      "integrations": {
+        "identityUpgrade": "disabled",
+        "presentation": "available",
+        "sharing": "available",
+        "inboundShare": "available",
+        "notifications": "unsupported",
+        "presentationMode": "fullscreen"
+      },
       "policy": {
         "externalPaymentAllowed": false,
         "remoteExecutableCodeAllowed": false,
@@ -89,6 +105,14 @@
       "release": {
         "profile": "google-play"
       },
+      "integrations": {
+        "identityUpgrade": "configuration-required",
+        "presentation": "available",
+        "sharing": "configuration-required",
+        "inboundShare": "configuration-required",
+        "notifications": "configuration-required",
+        "presentationMode": "fullscreen"
+      },
       "policy": {
         "externalPaymentAllowed": false,
         "remoteExecutableCodeAllowed": false,
@@ -121,6 +145,14 @@
       "release": {
         "profile": "app-store"
       },
+      "integrations": {
+        "identityUpgrade": "configuration-required",
+        "presentation": "available",
+        "sharing": "configuration-required",
+        "inboundShare": "configuration-required",
+        "notifications": "configuration-required",
+        "presentationMode": "fullscreen"
+      },
       "policy": {
         "externalPaymentAllowed": false,
         "remoteExecutableCodeAllowed": false,
@@ -153,6 +185,14 @@
       "release": {
         "profile": "apps-in-toss"
       },
+      "integrations": {
+        "identityUpgrade": "configuration-required",
+        "presentation": "available",
+        "sharing": "available",
+        "inboundShare": "available",
+        "notifications": "configuration-required",
+        "presentationMode": "fullscreen"
+      },
       "policy": {
         "externalPaymentAllowed": false,
         "remoteExecutableCodeAllowed": false,
@@ -185,6 +225,14 @@
       "release": {
         "profile": "devvit"
       },
+      "integrations": {
+        "identityUpgrade": "configuration-required",
+        "presentation": "configuration-required",
+        "sharing": "configuration-required",
+        "inboundShare": "configuration-required",
+        "notifications": "approval-required",
+        "presentationMode": "inline-expanded"
+      },
       "policy": {
         "externalPaymentAllowed": false,
         "remoteExecutableCodeAllowed": false,