@mpgd/target-config 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (9) hide show
  1. package/LICENSE +21 -0
  2. package/dist/effective.d.ts +94 -0
  3. package/dist/effective.js +137 -0
  4. package/dist/index.d.ts +6 -0
  5. package/dist/index.js +749 -0
  6. package/dist/runtime.d.ts +106 -0
  7. package/dist/runtime.js +194 -0
  8. package/package.json +59 -0
  9. package/targets.json +133 -0
package/dist/index.js ADDED
@@ -0,0 +1,749 @@
1
+ import * as _a from "typia/lib/internal/_assertGuard";
2
+ import * as _b from "typia/lib/internal/_accessExpressionAsString";
3
+ const __typia_transform__accessExpressionAsString = _b._accessExpressionAsString;
4
+ import typia from 'typia';
5
+ export * from './effective';
6
+ export * from './runtime';
7
+ export const assertEffectiveTargetConfigMatrix = (() => {
8
+ const _ip0 = input => "string" === typeof input["version"];
9
+ const _ip1 = input => "boolean" === typeof input["iap"];
10
+ const _ip2 = input => "boolean" === typeof input["rewardedAds"];
11
+ const _ip3 = input => "boolean" === typeof input["interstitialAds"];
12
+ const _ip4 = input => "boolean" === typeof input["localization"];
13
+ const _ip5 = input => "boolean" === typeof input["enabled"];
14
+ const _ip6 = input => "available" === input["reason"] || "capability-unsupported" === input["reason"] || "missing-platform-id" === input["reason"] || "target-disabled" === input["reason"];
15
+ const _ip7 = input => "currency" === input["type"];
16
+ const _ip8 = input => "coin" === input["currency"] || "gem" === input["currency"];
17
+ const _ip9 = input => "number" === typeof input["amount"];
18
+ const _ap0 = (input, _path, _exceptionable = true) => "string" === typeof input["version"] || _a._assertGuard(_exceptionable, {
19
+ method: "typia.createAssert",
20
+ path: _path + ".version",
21
+ expected: "string",
22
+ value: input["version"]
23
+ }, _errorFactory);
24
+ const _ap1 = (input, _path, _exceptionable = true) => "boolean" === typeof input["iap"] || _a._assertGuard(_exceptionable, {
25
+ method: "typia.createAssert",
26
+ path: _path + ".iap",
27
+ expected: "boolean",
28
+ value: input["iap"]
29
+ }, _errorFactory);
30
+ const _ap2 = (input, _path, _exceptionable = true) => "boolean" === typeof input["rewardedAds"] || _a._assertGuard(_exceptionable, {
31
+ method: "typia.createAssert",
32
+ path: _path + ".rewardedAds",
33
+ expected: "boolean",
34
+ value: input["rewardedAds"]
35
+ }, _errorFactory);
36
+ const _ap3 = (input, _path, _exceptionable = true) => "boolean" === typeof input["interstitialAds"] || _a._assertGuard(_exceptionable, {
37
+ method: "typia.createAssert",
38
+ path: _path + ".interstitialAds",
39
+ expected: "boolean",
40
+ value: input["interstitialAds"]
41
+ }, _errorFactory);
42
+ const _ap4 = (input, _path, _exceptionable = true) => "boolean" === typeof input["localization"] || _a._assertGuard(_exceptionable, {
43
+ method: "typia.createAssert",
44
+ path: _path + ".localization",
45
+ expected: "boolean",
46
+ value: input["localization"]
47
+ }, _errorFactory);
48
+ const _ae0 = "({ readonly type: \"currency\"; readonly currency: \"coin\" | \"gem\"; readonly amount: number; } | { readonly type: \"entitlement\"; readonly entitlement: string; })";
49
+ const _ap5 = (input, _path, _exceptionable = true) => "boolean" === typeof input["enabled"] || _a._assertGuard(_exceptionable, {
50
+ method: "typia.createAssert",
51
+ path: _path + ".enabled",
52
+ expected: "boolean",
53
+ value: input["enabled"]
54
+ }, _errorFactory);
55
+ 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, {
56
+ method: "typia.createAssert",
57
+ path: _path + ".reason",
58
+ expected: "(\"available\" | \"capability-unsupported\" | \"missing-platform-id\" | \"target-disabled\")",
59
+ value: input["reason"]
60
+ }, _errorFactory);
61
+ const _ap7 = (input, _path, _exceptionable = true) => "currency" === input["type"] || _a._assertGuard(_exceptionable, {
62
+ method: "typia.createAssert",
63
+ path: _path + ".type",
64
+ expected: "\"currency\"",
65
+ value: input["type"]
66
+ }, _errorFactory);
67
+ const _ap8 = (input, _path, _exceptionable = true) => "coin" === input["currency"] || "gem" === input["currency"] || _a._assertGuard(_exceptionable, {
68
+ method: "typia.createAssert",
69
+ path: _path + ".currency",
70
+ expected: "(\"coin\" | \"gem\")",
71
+ value: input["currency"]
72
+ }, _errorFactory);
73
+ const _ap9 = (input, _path, _exceptionable = true) => "number" === typeof input["amount"] || _a._assertGuard(_exceptionable, {
74
+ method: "typia.createAssert",
75
+ path: _path + ".amount",
76
+ expected: "number",
77
+ value: input["amount"]
78
+ }, _errorFactory);
79
+ const _ae1 = "(undefined | { readonly type: \"continue\"; readonly amount: number; } | { readonly type: \"currency\"; readonly amount: number; readonly currency: \"coin\" | \"gem\"; })";
80
+ const _ae2 = "({ readonly type: \"continue\"; readonly amount: number; } | { readonly type: \"currency\"; readonly amount: number; readonly currency: \"coin\" | \"gem\"; })";
81
+ const _ao0 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && (("object" === typeof input.targets && null !== input.targets && false === Array.isArray(input.targets) || _a._assertGuard(_exceptionable, {
82
+ method: "typia.createAssert",
83
+ path: _path + ".targets",
84
+ expected: "Record<string, EffectiveTargetConfig>",
85
+ value: input.targets
86
+ }, _errorFactory)) && _ao1(input.targets, _path + ".targets", true && _exceptionable) || _a._assertGuard(_exceptionable, {
87
+ method: "typia.createAssert",
88
+ path: _path + ".targets",
89
+ expected: "Record<string, EffectiveTargetConfig>",
90
+ value: input.targets
91
+ }, _errorFactory));
92
+ const _ao1 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every(key => {
93
+ const value = input[key];
94
+ if (undefined === value)
95
+ return true;
96
+ return ("object" === typeof value && null !== value || _a._assertGuard(_exceptionable, {
97
+ method: "typia.createAssert",
98
+ path: _path + __typia_transform__accessExpressionAsString(key),
99
+ expected: "EffectiveTargetConfig",
100
+ value: value
101
+ }, _errorFactory)) && _ao2(value, _path + __typia_transform__accessExpressionAsString(key), true && _exceptionable) || _a._assertGuard(_exceptionable, {
102
+ method: "typia.createAssert",
103
+ path: _path + __typia_transform__accessExpressionAsString(key),
104
+ expected: "EffectiveTargetConfig",
105
+ value: value
106
+ }, _errorFactory);
107
+ });
108
+ const _ao10 = (input, _path, _exceptionable = true) => _ap7(input, _path, true && _exceptionable) && _ap8(input, _path, true && _exceptionable) && _ap9(input, _path, true && _exceptionable);
109
+ const _ao11 = (input, _path, _exceptionable = true) => ("entitlement" === input.type || _a._assertGuard(_exceptionable, {
110
+ method: "typia.createAssert",
111
+ path: _path + ".type",
112
+ expected: "\"entitlement\"",
113
+ value: input.type
114
+ }, _errorFactory)) && ("string" === typeof input.entitlement || _a._assertGuard(_exceptionable, {
115
+ method: "typia.createAssert",
116
+ path: _path + ".entitlement",
117
+ expected: "string",
118
+ value: input.entitlement
119
+ }, _errorFactory));
120
+ const _ao12 = (input, _path, _exceptionable = true) => _ap2(input, _path, true && _exceptionable) && _ap3(input, _path, true && _exceptionable) && ((Array.isArray(input.placements) || _a._assertGuard(_exceptionable, {
121
+ method: "typia.createAssert",
122
+ path: _path + ".placements",
123
+ expected: "ReadonlyArray<EffectiveAdPlacementConfig>",
124
+ value: input.placements
125
+ }, _errorFactory)) && input.placements.every((elem, _index4) => ("object" === typeof elem && null !== elem || _a._assertGuard(_exceptionable, {
126
+ method: "typia.createAssert",
127
+ path: _path + ".placements[" + _index4 + "]",
128
+ expected: "EffectiveAdPlacementConfig",
129
+ value: elem
130
+ }, _errorFactory)) && _ao13(elem, _path + ".placements[" + _index4 + "]", true && _exceptionable) || _a._assertGuard(_exceptionable, {
131
+ method: "typia.createAssert",
132
+ path: _path + ".placements[" + _index4 + "]",
133
+ expected: "EffectiveAdPlacementConfig",
134
+ value: elem
135
+ }, _errorFactory)) || _a._assertGuard(_exceptionable, {
136
+ method: "typia.createAssert",
137
+ path: _path + ".placements",
138
+ expected: "ReadonlyArray<EffectiveAdPlacementConfig>",
139
+ value: input.placements
140
+ }, _errorFactory));
141
+ const _ao13 = (input, _path, _exceptionable = true) => ("CONTINUE_AFTER_FAIL" === input.id || "STAGE_END_INTERSTITIAL" === input.id || _a._assertGuard(_exceptionable, {
142
+ method: "typia.createAssert",
143
+ path: _path + ".id",
144
+ expected: "(\"CONTINUE_AFTER_FAIL\" | \"STAGE_END_INTERSTITIAL\")",
145
+ value: input.id
146
+ }, _errorFactory)) && ("interstitial" === input.type || "rewarded" === input.type || _a._assertGuard(_exceptionable, {
147
+ method: "typia.createAssert",
148
+ path: _path + ".type",
149
+ expected: "(\"interstitial\" | \"rewarded\")",
150
+ value: input.type
151
+ }, _errorFactory)) && (undefined === input.reward || ("object" === typeof input.reward && null !== input.reward || _a._assertGuard(_exceptionable, {
152
+ method: "typia.createAssert",
153
+ path: _path + ".reward",
154
+ expected: _ae1,
155
+ value: input.reward
156
+ }, _errorFactory)) && _au1(input.reward, _path + ".reward", true && _exceptionable) || _a._assertGuard(_exceptionable, {
157
+ method: "typia.createAssert",
158
+ path: _path + ".reward",
159
+ expected: _ae1,
160
+ value: input.reward
161
+ }, _errorFactory)) && (("object" === typeof input.frequencyCap && null !== input.frequencyCap || _a._assertGuard(_exceptionable, {
162
+ method: "typia.createAssert",
163
+ path: _path + ".frequencyCap",
164
+ expected: "FrequencyCap",
165
+ value: input.frequencyCap
166
+ }, _errorFactory)) && _ao16(input.frequencyCap, _path + ".frequencyCap", true && _exceptionable) || _a._assertGuard(_exceptionable, {
167
+ method: "typia.createAssert",
168
+ path: _path + ".frequencyCap",
169
+ expected: "FrequencyCap",
170
+ value: input.frequencyCap
171
+ }, _errorFactory)) && _ap5(input, _path, true && _exceptionable) && _ap6(input, _path, true && _exceptionable) && (undefined === input.platformPlacementId || "string" === typeof input.platformPlacementId || _a._assertGuard(_exceptionable, {
172
+ method: "typia.createAssert",
173
+ path: _path + ".platformPlacementId",
174
+ expected: "(string | undefined)",
175
+ value: input.platformPlacementId
176
+ }, _errorFactory));
177
+ const _ao14 = (input, _path, _exceptionable = true) => ("continue" === input.type || _a._assertGuard(_exceptionable, {
178
+ method: "typia.createAssert",
179
+ path: _path + ".type",
180
+ expected: "\"continue\"",
181
+ value: input.type
182
+ }, _errorFactory)) && _ap9(input, _path, true && _exceptionable);
183
+ const _ao15 = (input, _path, _exceptionable = true) => _ap7(input, _path, true && _exceptionable) && _ap9(input, _path, true && _exceptionable) && _ap8(input, _path, true && _exceptionable);
184
+ const _ao16 = (input, _path, _exceptionable = true) => ("number" === typeof input.cooldownSeconds || _a._assertGuard(_exceptionable, {
185
+ method: "typia.createAssert",
186
+ path: _path + ".cooldownSeconds",
187
+ expected: "number",
188
+ value: input.cooldownSeconds
189
+ }, _errorFactory)) && (undefined === input.maxPerSession || "number" === typeof input.maxPerSession || _a._assertGuard(_exceptionable, {
190
+ method: "typia.createAssert",
191
+ path: _path + ".maxPerSession",
192
+ expected: "(number | undefined)",
193
+ value: input.maxPerSession
194
+ }, _errorFactory)) && (undefined === input.minStageInterval || "number" === typeof input.minStageInterval || _a._assertGuard(_exceptionable, {
195
+ method: "typia.createAssert",
196
+ path: _path + ".minStageInterval",
197
+ expected: "(number | undefined)",
198
+ value: input.minStageInterval
199
+ }, _errorFactory));
200
+ const _ao17 = (input, _path, _exceptionable = true) => ("boolean" === typeof input.native || _a._assertGuard(_exceptionable, {
201
+ method: "typia.createAssert",
202
+ path: _path + ".native",
203
+ expected: "boolean",
204
+ value: input.native
205
+ }, _errorFactory)) && _ap5(input, _path, true && _exceptionable) && ("available" === input.reason || "capability-unsupported" === input.reason || "target-disabled" === input.reason || _a._assertGuard(_exceptionable, {
206
+ method: "typia.createAssert",
207
+ path: _path + ".reason",
208
+ expected: "(\"available\" | \"capability-unsupported\" | \"target-disabled\")",
209
+ value: input.reason
210
+ }, _errorFactory)) && (undefined === input.defaultLeaderboardId || "string" === typeof input.defaultLeaderboardId || _a._assertGuard(_exceptionable, {
211
+ method: "typia.createAssert",
212
+ path: _path + ".defaultLeaderboardId",
213
+ expected: "(string | undefined)",
214
+ value: input.defaultLeaderboardId
215
+ }, _errorFactory));
216
+ const _ao18 = (input, _path, _exceptionable = true) => ("local" === input.support || "native" === input.support || "none" === input.support || _a._assertGuard(_exceptionable, {
217
+ method: "typia.createAssert",
218
+ path: _path + ".support",
219
+ expected: "(\"local\" | \"native\" | \"none\")",
220
+ value: input.support
221
+ }, _errorFactory)) && _ap5(input, _path, true && _exceptionable);
222
+ const _ao19 = (input, _path, _exceptionable = true) => _ap5(input, _path, true && _exceptionable);
223
+ const _ao2 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && ("string" === typeof input.target || _a._assertGuard(_exceptionable, {
224
+ method: "typia.createAssert",
225
+ path: _path + ".target",
226
+ expected: "string",
227
+ value: input.target
228
+ }, _errorFactory)) && ("apps-in-toss" === input.runtime || "capacitor-android" === input.runtime || "capacitor-ios" === input.runtime || "web-preview" === input.runtime || _a._assertGuard(_exceptionable, {
229
+ method: "typia.createAssert",
230
+ path: _path + ".runtime",
231
+ expected: "(\"apps-in-toss\" | \"capacitor-android\" | \"capacitor-ios\" | \"web-preview\")",
232
+ value: input.runtime
233
+ }, _errorFactory)) && (("object" === typeof input.release && null !== input.release || _a._assertGuard(_exceptionable, {
234
+ method: "typia.createAssert",
235
+ path: _path + ".release",
236
+ expected: "TargetReleaseConfig",
237
+ value: input.release
238
+ }, _errorFactory)) && _ao3(input.release, _path + ".release", true && _exceptionable) || _a._assertGuard(_exceptionable, {
239
+ method: "typia.createAssert",
240
+ path: _path + ".release",
241
+ expected: "TargetReleaseConfig",
242
+ value: input.release
243
+ }, _errorFactory)) && (("object" === typeof input.features && null !== input.features || _a._assertGuard(_exceptionable, {
244
+ method: "typia.createAssert",
245
+ path: _path + ".features",
246
+ expected: "TargetFeatureConfig",
247
+ value: input.features
248
+ }, _errorFactory)) && _ao4(input.features, _path + ".features", true && _exceptionable) || _a._assertGuard(_exceptionable, {
249
+ method: "typia.createAssert",
250
+ path: _path + ".features",
251
+ expected: "TargetFeatureConfig",
252
+ value: input.features
253
+ }, _errorFactory)) && (("object" === typeof input.capabilities && null !== input.capabilities || _a._assertGuard(_exceptionable, {
254
+ method: "typia.createAssert",
255
+ path: _path + ".capabilities",
256
+ expected: "TargetCapabilityConfig",
257
+ value: input.capabilities
258
+ }, _errorFactory)) && _ao5(input.capabilities, _path + ".capabilities", true && _exceptionable) || _a._assertGuard(_exceptionable, {
259
+ method: "typia.createAssert",
260
+ path: _path + ".capabilities",
261
+ expected: "TargetCapabilityConfig",
262
+ value: input.capabilities
263
+ }, _errorFactory)) && (("object" === typeof input.policy && null !== input.policy || _a._assertGuard(_exceptionable, {
264
+ method: "typia.createAssert",
265
+ path: _path + ".policy",
266
+ expected: "TargetPolicyRestrictions",
267
+ value: input.policy
268
+ }, _errorFactory)) && _ao6(input.policy, _path + ".policy", true && _exceptionable) || _a._assertGuard(_exceptionable, {
269
+ method: "typia.createAssert",
270
+ path: _path + ".policy",
271
+ expected: "TargetPolicyRestrictions",
272
+ value: input.policy
273
+ }, _errorFactory)) && (("object" === typeof input.sources && null !== input.sources || _a._assertGuard(_exceptionable, {
274
+ method: "typia.createAssert",
275
+ path: _path + ".sources",
276
+ expected: "EffectiveTargetConfigSources",
277
+ value: input.sources
278
+ }, _errorFactory)) && _ao7(input.sources, _path + ".sources", true && _exceptionable) || _a._assertGuard(_exceptionable, {
279
+ method: "typia.createAssert",
280
+ path: _path + ".sources",
281
+ expected: "EffectiveTargetConfigSources",
282
+ value: input.sources
283
+ }, _errorFactory)) && (("object" === typeof input.monetization && null !== input.monetization || _a._assertGuard(_exceptionable, {
284
+ method: "typia.createAssert",
285
+ path: _path + ".monetization",
286
+ expected: "EffectiveMonetizationConfig",
287
+ value: input.monetization
288
+ }, _errorFactory)) && _ao8(input.monetization, _path + ".monetization", true && _exceptionable) || _a._assertGuard(_exceptionable, {
289
+ method: "typia.createAssert",
290
+ path: _path + ".monetization",
291
+ expected: "EffectiveMonetizationConfig",
292
+ value: input.monetization
293
+ }, _errorFactory)) && (("object" === typeof input.ads && null !== input.ads || _a._assertGuard(_exceptionable, {
294
+ method: "typia.createAssert",
295
+ path: _path + ".ads",
296
+ expected: "EffectiveAdsConfig",
297
+ value: input.ads
298
+ }, _errorFactory)) && _ao12(input.ads, _path + ".ads", true && _exceptionable) || _a._assertGuard(_exceptionable, {
299
+ method: "typia.createAssert",
300
+ path: _path + ".ads",
301
+ expected: "EffectiveAdsConfig",
302
+ value: input.ads
303
+ }, _errorFactory)) && (("object" === typeof input.leaderboard && null !== input.leaderboard || _a._assertGuard(_exceptionable, {
304
+ method: "typia.createAssert",
305
+ path: _path + ".leaderboard",
306
+ expected: "EffectiveLeaderboardConfig",
307
+ value: input.leaderboard
308
+ }, _errorFactory)) && _ao17(input.leaderboard, _path + ".leaderboard", true && _exceptionable) || _a._assertGuard(_exceptionable, {
309
+ method: "typia.createAssert",
310
+ path: _path + ".leaderboard",
311
+ expected: "EffectiveLeaderboardConfig",
312
+ value: input.leaderboard
313
+ }, _errorFactory)) && (("object" === typeof input.storage && null !== input.storage || _a._assertGuard(_exceptionable, {
314
+ method: "typia.createAssert",
315
+ path: _path + ".storage",
316
+ expected: "EffectiveStorageConfig",
317
+ value: input.storage
318
+ }, _errorFactory)) && _ao18(input.storage, _path + ".storage", true && _exceptionable) || _a._assertGuard(_exceptionable, {
319
+ method: "typia.createAssert",
320
+ path: _path + ".storage",
321
+ expected: "EffectiveStorageConfig",
322
+ value: input.storage
323
+ }, _errorFactory)) && (("object" === typeof input.localization && null !== input.localization || _a._assertGuard(_exceptionable, {
324
+ method: "typia.createAssert",
325
+ path: _path + ".localization",
326
+ expected: "EffectiveLocalizationConfig",
327
+ value: input.localization
328
+ }, _errorFactory)) && _ao19(input.localization, _path + ".localization", true && _exceptionable) || _a._assertGuard(_exceptionable, {
329
+ method: "typia.createAssert",
330
+ path: _path + ".localization",
331
+ expected: "EffectiveLocalizationConfig",
332
+ value: input.localization
333
+ }, _errorFactory));
334
+ const _ao3 = (input, _path, _exceptionable = true) => "app-store" === input.profile || "apps-in-toss" === input.profile || "google-play" === input.profile || "web-preview" === input.profile || _a._assertGuard(_exceptionable, {
335
+ method: "typia.createAssert",
336
+ path: _path + ".profile",
337
+ expected: "(\"app-store\" | \"apps-in-toss\" | \"google-play\" | \"web-preview\")",
338
+ value: input.profile
339
+ }, _errorFactory);
340
+ const _ao4 = (input, _path, _exceptionable = true) => _ap1(input, _path, true && _exceptionable) && _ap2(input, _path, true && _exceptionable) && _ap3(input, _path, true && _exceptionable) && ("boolean" === typeof input.leaderboard || _a._assertGuard(_exceptionable, {
341
+ method: "typia.createAssert",
342
+ path: _path + ".leaderboard",
343
+ expected: "boolean",
344
+ value: input.leaderboard
345
+ }, _errorFactory)) && _ap4(input, _path, true && _exceptionable);
346
+ const _ao5 = (input, _path, _exceptionable = true) => ("local" === input.storage || "native" === input.storage || "none" === input.storage || _a._assertGuard(_exceptionable, {
347
+ method: "typia.createAssert",
348
+ path: _path + ".storage",
349
+ expected: "(\"local\" | \"native\" | \"none\")",
350
+ value: input.storage
351
+ }, _errorFactory)) && _ap4(input, _path, true && _exceptionable);
352
+ const _ao6 = (input, _path, _exceptionable = true) => ("boolean" === typeof input.externalPaymentAllowed || _a._assertGuard(_exceptionable, {
353
+ method: "typia.createAssert",
354
+ path: _path + ".externalPaymentAllowed",
355
+ expected: "boolean",
356
+ value: input.externalPaymentAllowed
357
+ }, _errorFactory)) && ("boolean" === typeof input.remoteExecutableCodeAllowed || _a._assertGuard(_exceptionable, {
358
+ method: "typia.createAssert",
359
+ path: _path + ".remoteExecutableCodeAllowed",
360
+ expected: "boolean",
361
+ value: input.remoteExecutableCodeAllowed
362
+ }, _errorFactory)) && ("boolean" === typeof input.installOtherAppCTAAllowed || _a._assertGuard(_exceptionable, {
363
+ method: "typia.createAssert",
364
+ path: _path + ".installOtherAppCTAAllowed",
365
+ expected: "boolean",
366
+ value: input.installOtherAppCTAAllowed
367
+ }, _errorFactory)) && ("boolean" === typeof input.requiresStoreReview || _a._assertGuard(_exceptionable, {
368
+ method: "typia.createAssert",
369
+ path: _path + ".requiresStoreReview",
370
+ expected: "boolean",
371
+ value: input.requiresStoreReview
372
+ }, _errorFactory)) && ("boolean" === typeof input.requiresAitReview || _a._assertGuard(_exceptionable, {
373
+ method: "typia.createAssert",
374
+ path: _path + ".requiresAitReview",
375
+ expected: "boolean",
376
+ value: input.requiresAitReview
377
+ }, _errorFactory));
378
+ const _ao7 = (input, _path, _exceptionable = true) => ("string" === typeof input.targetConfig || _a._assertGuard(_exceptionable, {
379
+ method: "typia.createAssert",
380
+ path: _path + ".targetConfig",
381
+ expected: "string",
382
+ value: input.targetConfig
383
+ }, _errorFactory)) && ("string" === typeof input.productCatalog || _a._assertGuard(_exceptionable, {
384
+ method: "typia.createAssert",
385
+ path: _path + ".productCatalog",
386
+ expected: "string",
387
+ value: input.productCatalog
388
+ }, _errorFactory)) && ("string" === typeof input.adPlacements || _a._assertGuard(_exceptionable, {
389
+ method: "typia.createAssert",
390
+ path: _path + ".adPlacements",
391
+ expected: "string",
392
+ value: input.adPlacements
393
+ }, _errorFactory)) && (undefined === input.platformTargetKind || "string" === typeof input.platformTargetKind || _a._assertGuard(_exceptionable, {
394
+ method: "typia.createAssert",
395
+ path: _path + ".platformTargetKind",
396
+ expected: "(string | undefined)",
397
+ value: input.platformTargetKind
398
+ }, _errorFactory)) && (undefined === input.platformAdapter || "string" === typeof input.platformAdapter || _a._assertGuard(_exceptionable, {
399
+ method: "typia.createAssert",
400
+ path: _path + ".platformAdapter",
401
+ expected: "(string | undefined)",
402
+ value: input.platformAdapter
403
+ }, _errorFactory));
404
+ const _ao8 = (input, _path, _exceptionable = true) => _ap1(input, _path, true && _exceptionable) && ((Array.isArray(input.products) || _a._assertGuard(_exceptionable, {
405
+ method: "typia.createAssert",
406
+ path: _path + ".products",
407
+ expected: "ReadonlyArray<EffectiveProductConfig>",
408
+ value: input.products
409
+ }, _errorFactory)) && input.products.every((elem, _index3) => ("object" === typeof elem && null !== elem || _a._assertGuard(_exceptionable, {
410
+ method: "typia.createAssert",
411
+ path: _path + ".products[" + _index3 + "]",
412
+ expected: "EffectiveProductConfig",
413
+ value: elem
414
+ }, _errorFactory)) && _ao9(elem, _path + ".products[" + _index3 + "]", true && _exceptionable) || _a._assertGuard(_exceptionable, {
415
+ method: "typia.createAssert",
416
+ path: _path + ".products[" + _index3 + "]",
417
+ expected: "EffectiveProductConfig",
418
+ value: elem
419
+ }, _errorFactory)) || _a._assertGuard(_exceptionable, {
420
+ method: "typia.createAssert",
421
+ path: _path + ".products",
422
+ expected: "ReadonlyArray<EffectiveProductConfig>",
423
+ value: input.products
424
+ }, _errorFactory));
425
+ const _ao9 = (input, _path, _exceptionable = true) => ("COINS_100" === input.id || "COINS_500" === input.id || "REMOVE_ADS" === input.id || _a._assertGuard(_exceptionable, {
426
+ method: "typia.createAssert",
427
+ path: _path + ".id",
428
+ expected: "(\"COINS_100\" | \"COINS_500\" | \"REMOVE_ADS\")",
429
+ value: input.id
430
+ }, _errorFactory)) && ("consumable" === input.type || "non_consumable" === input.type || "subscription" === input.type || _a._assertGuard(_exceptionable, {
431
+ method: "typia.createAssert",
432
+ path: _path + ".type",
433
+ expected: "(\"consumable\" | \"non_consumable\" | \"subscription\")",
434
+ value: input.type
435
+ }, _errorFactory)) && (("object" === typeof input.grant && null !== input.grant || _a._assertGuard(_exceptionable, {
436
+ method: "typia.createAssert",
437
+ path: _path + ".grant",
438
+ expected: _ae0,
439
+ value: input.grant
440
+ }, _errorFactory)) && _au0(input.grant, _path + ".grant", true && _exceptionable) || _a._assertGuard(_exceptionable, {
441
+ method: "typia.createAssert",
442
+ path: _path + ".grant",
443
+ expected: _ae0,
444
+ value: input.grant
445
+ }, _errorFactory)) && _ap5(input, _path, true && _exceptionable) && _ap6(input, _path, true && _exceptionable) && (undefined === input.platformProductId || "string" === typeof input.platformProductId || _a._assertGuard(_exceptionable, {
446
+ method: "typia.createAssert",
447
+ path: _path + ".platformProductId",
448
+ expected: "(string | undefined)",
449
+ value: input.platformProductId
450
+ }, _errorFactory));
451
+ const _au0 = (input, _path, _exceptionable = true) => (() => {
452
+ if ("currency" === input.type)
453
+ return _ao10(input, _path, true && _exceptionable);
454
+ else if ("entitlement" === input.type)
455
+ return _ao11(input, _path, true && _exceptionable);
456
+ else
457
+ return _a._assertGuard(_exceptionable, {
458
+ method: "typia.createAssert",
459
+ path: _path,
460
+ expected: _ae0,
461
+ value: input
462
+ }, _errorFactory);
463
+ })();
464
+ const _au1 = (input, _path, _exceptionable = true) => (() => {
465
+ if ("continue" === input.type)
466
+ return _ao14(input, _path, true && _exceptionable);
467
+ else if ("currency" === input.type)
468
+ return _ao15(input, _path, true && _exceptionable);
469
+ else
470
+ return _a._assertGuard(_exceptionable, {
471
+ method: "typia.createAssert",
472
+ path: _path,
473
+ expected: _ae2,
474
+ value: input
475
+ }, _errorFactory);
476
+ })();
477
+ const _io0 = input => _ip0(input) && ("object" === typeof input.targets && null !== input.targets && false === Array.isArray(input.targets) && _io1(input.targets));
478
+ const _io1 = input => Object.keys(input).every(key => {
479
+ const value = input[key];
480
+ if (undefined === value)
481
+ return true;
482
+ return "object" === typeof value && null !== value && _io2(value);
483
+ });
484
+ const _io10 = input => _ip7(input) && _ip8(input) && _ip9(input);
485
+ const _io11 = input => "entitlement" === input.type && "string" === typeof input.entitlement;
486
+ const _io12 = input => _ip2(input) && _ip3(input) && (Array.isArray(input.placements) && input.placements.every(elem => "object" === typeof elem && null !== elem && _io13(elem)));
487
+ 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);
488
+ const _io14 = input => "continue" === input.type && _ip9(input);
489
+ const _io15 = input => _ip7(input) && _ip9(input) && _ip8(input);
490
+ const _io16 = input => "number" === typeof input.cooldownSeconds && (undefined === input.maxPerSession || "number" === typeof input.maxPerSession) && (undefined === input.minStageInterval || "number" === typeof input.minStageInterval);
491
+ 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);
492
+ const _io18 = input => ("local" === input.support || "native" === input.support || "none" === input.support) && _ip5(input);
493
+ const _io19 = input => _ip5(input);
494
+ const _io2 = input => _ip0(input) && "string" === typeof input.target && ("apps-in-toss" === input.runtime || "capacitor-android" === input.runtime || "capacitor-ios" === 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));
495
+ const _io3 = input => "app-store" === input.profile || "apps-in-toss" === input.profile || "google-play" === input.profile || "web-preview" === input.profile;
496
+ const _io4 = input => _ip1(input) && _ip2(input) && _ip3(input) && "boolean" === typeof input.leaderboard && _ip4(input);
497
+ const _io5 = input => ("local" === input.storage || "native" === input.storage || "none" === input.storage) && _ip4(input);
498
+ const _io6 = input => "boolean" === typeof input.externalPaymentAllowed && "boolean" === typeof input.remoteExecutableCodeAllowed && "boolean" === typeof input.installOtherAppCTAAllowed && "boolean" === typeof input.requiresStoreReview && "boolean" === typeof input.requiresAitReview;
499
+ 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);
500
+ const _io8 = input => _ip1(input) && (Array.isArray(input.products) && input.products.every(elem => "object" === typeof elem && null !== elem && _io9(elem)));
501
+ 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);
502
+ const _iu0 = input => (() => {
503
+ if ("currency" === input.type)
504
+ return _io10(input);
505
+ else if ("entitlement" === input.type)
506
+ return _io11(input);
507
+ else
508
+ return false;
509
+ })();
510
+ const _iu1 = input => (() => {
511
+ if ("continue" === input.type)
512
+ return _io14(input);
513
+ else if ("currency" === input.type)
514
+ return _io15(input);
515
+ else
516
+ return false;
517
+ })();
518
+ const __is = input => "object" === typeof input && null !== input && _io0(input);
519
+ let _errorFactory;
520
+ return (input, errorFactory) => {
521
+ if (false === __is(input)) {
522
+ _errorFactory = errorFactory;
523
+ ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _a._assertGuard(true, {
524
+ method: "typia.createAssert",
525
+ path: _path + "",
526
+ expected: "EffectiveTargetConfigMatrix",
527
+ value: input
528
+ }, _errorFactory)) && _ao0(input, _path + "", true) || _a._assertGuard(true, {
529
+ method: "typia.createAssert",
530
+ path: _path + "",
531
+ expected: "EffectiveTargetConfigMatrix",
532
+ value: input
533
+ }, _errorFactory))(input, "$input", true);
534
+ }
535
+ return input;
536
+ };
537
+ })();
538
+ export const assertTargetConfigMatrix = (() => {
539
+ const _ip0 = input => "boolean" === typeof input["iap"];
540
+ const _ip1 = input => "boolean" === typeof input["rewardedAds"];
541
+ const _ip2 = input => "boolean" === typeof input["interstitialAds"];
542
+ const _ip3 = input => "boolean" === typeof input["localization"];
543
+ const _ap0 = (input, _path, _exceptionable = true) => "boolean" === typeof input["iap"] || _a._assertGuard(_exceptionable, {
544
+ method: "typia.createAssert",
545
+ path: _path + ".iap",
546
+ expected: "boolean",
547
+ value: input["iap"]
548
+ }, _errorFactory);
549
+ const _ap1 = (input, _path, _exceptionable = true) => "boolean" === typeof input["rewardedAds"] || _a._assertGuard(_exceptionable, {
550
+ method: "typia.createAssert",
551
+ path: _path + ".rewardedAds",
552
+ expected: "boolean",
553
+ value: input["rewardedAds"]
554
+ }, _errorFactory);
555
+ const _ap2 = (input, _path, _exceptionable = true) => "boolean" === typeof input["interstitialAds"] || _a._assertGuard(_exceptionable, {
556
+ method: "typia.createAssert",
557
+ path: _path + ".interstitialAds",
558
+ expected: "boolean",
559
+ value: input["interstitialAds"]
560
+ }, _errorFactory);
561
+ const _ap3 = (input, _path, _exceptionable = true) => "boolean" === typeof input["localization"] || _a._assertGuard(_exceptionable, {
562
+ method: "typia.createAssert",
563
+ path: _path + ".localization",
564
+ expected: "boolean",
565
+ value: input["localization"]
566
+ }, _errorFactory);
567
+ const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.version || _a._assertGuard(_exceptionable, {
568
+ method: "typia.createAssert",
569
+ path: _path + ".version",
570
+ expected: "string",
571
+ value: input.version
572
+ }, _errorFactory)) && (("object" === typeof input.targets && null !== input.targets && false === Array.isArray(input.targets) || _a._assertGuard(_exceptionable, {
573
+ method: "typia.createAssert",
574
+ path: _path + ".targets",
575
+ expected: "Record<string, TargetConfig>",
576
+ value: input.targets
577
+ }, _errorFactory)) && _ao1(input.targets, _path + ".targets", true && _exceptionable) || _a._assertGuard(_exceptionable, {
578
+ method: "typia.createAssert",
579
+ path: _path + ".targets",
580
+ expected: "Record<string, TargetConfig>",
581
+ value: input.targets
582
+ }, _errorFactory));
583
+ const _ao1 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every(key => {
584
+ const value = input[key];
585
+ if (undefined === value)
586
+ return true;
587
+ return ("object" === typeof value && null !== value || _a._assertGuard(_exceptionable, {
588
+ method: "typia.createAssert",
589
+ path: _path + __typia_transform__accessExpressionAsString(key),
590
+ expected: "TargetConfig",
591
+ value: value
592
+ }, _errorFactory)) && _ao2(value, _path + __typia_transform__accessExpressionAsString(key), true && _exceptionable) || _a._assertGuard(_exceptionable, {
593
+ method: "typia.createAssert",
594
+ path: _path + __typia_transform__accessExpressionAsString(key),
595
+ expected: "TargetConfig",
596
+ value: value
597
+ }, _errorFactory);
598
+ });
599
+ const _ao2 = (input, _path, _exceptionable = true) => ("apps-in-toss" === input.runtime || "capacitor-android" === input.runtime || "capacitor-ios" === input.runtime || "web-preview" === input.runtime || _a._assertGuard(_exceptionable, {
600
+ method: "typia.createAssert",
601
+ path: _path + ".runtime",
602
+ expected: "(\"apps-in-toss\" | \"capacitor-android\" | \"capacitor-ios\" | \"web-preview\")",
603
+ value: input.runtime
604
+ }, _errorFactory)) && (("object" === typeof input.features && null !== input.features || _a._assertGuard(_exceptionable, {
605
+ method: "typia.createAssert",
606
+ path: _path + ".features",
607
+ expected: "TargetFeatureConfig",
608
+ value: input.features
609
+ }, _errorFactory)) && _ao3(input.features, _path + ".features", true && _exceptionable) || _a._assertGuard(_exceptionable, {
610
+ method: "typia.createAssert",
611
+ path: _path + ".features",
612
+ expected: "TargetFeatureConfig",
613
+ value: input.features
614
+ }, _errorFactory)) && (("object" === typeof input.capabilities && null !== input.capabilities || _a._assertGuard(_exceptionable, {
615
+ method: "typia.createAssert",
616
+ path: _path + ".capabilities",
617
+ expected: "TargetCapabilityConfig",
618
+ value: input.capabilities
619
+ }, _errorFactory)) && _ao4(input.capabilities, _path + ".capabilities", true && _exceptionable) || _a._assertGuard(_exceptionable, {
620
+ method: "typia.createAssert",
621
+ path: _path + ".capabilities",
622
+ expected: "TargetCapabilityConfig",
623
+ value: input.capabilities
624
+ }, _errorFactory)) && (("object" === typeof input.monetization && null !== input.monetization || _a._assertGuard(_exceptionable, {
625
+ method: "typia.createAssert",
626
+ path: _path + ".monetization",
627
+ expected: "TargetMonetizationConfig",
628
+ value: input.monetization
629
+ }, _errorFactory)) && _ao5(input.monetization, _path + ".monetization", true && _exceptionable) || _a._assertGuard(_exceptionable, {
630
+ method: "typia.createAssert",
631
+ path: _path + ".monetization",
632
+ expected: "TargetMonetizationConfig",
633
+ value: input.monetization
634
+ }, _errorFactory)) && (("object" === typeof input.leaderboard && null !== input.leaderboard || _a._assertGuard(_exceptionable, {
635
+ method: "typia.createAssert",
636
+ path: _path + ".leaderboard",
637
+ expected: "TargetLeaderboardConfig",
638
+ value: input.leaderboard
639
+ }, _errorFactory)) && _ao6(input.leaderboard, _path + ".leaderboard", true && _exceptionable) || _a._assertGuard(_exceptionable, {
640
+ method: "typia.createAssert",
641
+ path: _path + ".leaderboard",
642
+ expected: "TargetLeaderboardConfig",
643
+ value: input.leaderboard
644
+ }, _errorFactory)) && (("object" === typeof input.release && null !== input.release || _a._assertGuard(_exceptionable, {
645
+ method: "typia.createAssert",
646
+ path: _path + ".release",
647
+ expected: "TargetReleaseConfig",
648
+ value: input.release
649
+ }, _errorFactory)) && _ao7(input.release, _path + ".release", true && _exceptionable) || _a._assertGuard(_exceptionable, {
650
+ method: "typia.createAssert",
651
+ path: _path + ".release",
652
+ expected: "TargetReleaseConfig",
653
+ value: input.release
654
+ }, _errorFactory)) && (("object" === typeof input.policy && null !== input.policy || _a._assertGuard(_exceptionable, {
655
+ method: "typia.createAssert",
656
+ path: _path + ".policy",
657
+ expected: "TargetPolicyRestrictions",
658
+ value: input.policy
659
+ }, _errorFactory)) && _ao8(input.policy, _path + ".policy", true && _exceptionable) || _a._assertGuard(_exceptionable, {
660
+ method: "typia.createAssert",
661
+ path: _path + ".policy",
662
+ expected: "TargetPolicyRestrictions",
663
+ value: input.policy
664
+ }, _errorFactory));
665
+ 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, {
666
+ method: "typia.createAssert",
667
+ path: _path + ".leaderboard",
668
+ expected: "boolean",
669
+ value: input.leaderboard
670
+ }, _errorFactory)) && _ap3(input, _path, true && _exceptionable);
671
+ const _ao4 = (input, _path, _exceptionable = true) => ("local" === input.storage || "native" === input.storage || "none" === input.storage || _a._assertGuard(_exceptionable, {
672
+ method: "typia.createAssert",
673
+ path: _path + ".storage",
674
+ expected: "(\"local\" | \"native\" | \"none\")",
675
+ value: input.storage
676
+ }, _errorFactory)) && _ap3(input, _path, true && _exceptionable);
677
+ const _ao5 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && _ap1(input, _path, true && _exceptionable) && _ap2(input, _path, true && _exceptionable);
678
+ const _ao6 = (input, _path, _exceptionable = true) => "boolean" === typeof input.native || _a._assertGuard(_exceptionable, {
679
+ method: "typia.createAssert",
680
+ path: _path + ".native",
681
+ expected: "boolean",
682
+ value: input.native
683
+ }, _errorFactory);
684
+ const _ao7 = (input, _path, _exceptionable = true) => "app-store" === input.profile || "apps-in-toss" === input.profile || "google-play" === input.profile || "web-preview" === input.profile || _a._assertGuard(_exceptionable, {
685
+ method: "typia.createAssert",
686
+ path: _path + ".profile",
687
+ expected: "(\"app-store\" | \"apps-in-toss\" | \"google-play\" | \"web-preview\")",
688
+ value: input.profile
689
+ }, _errorFactory);
690
+ const _ao8 = (input, _path, _exceptionable = true) => ("boolean" === typeof input.externalPaymentAllowed || _a._assertGuard(_exceptionable, {
691
+ method: "typia.createAssert",
692
+ path: _path + ".externalPaymentAllowed",
693
+ expected: "boolean",
694
+ value: input.externalPaymentAllowed
695
+ }, _errorFactory)) && ("boolean" === typeof input.remoteExecutableCodeAllowed || _a._assertGuard(_exceptionable, {
696
+ method: "typia.createAssert",
697
+ path: _path + ".remoteExecutableCodeAllowed",
698
+ expected: "boolean",
699
+ value: input.remoteExecutableCodeAllowed
700
+ }, _errorFactory)) && ("boolean" === typeof input.installOtherAppCTAAllowed || _a._assertGuard(_exceptionable, {
701
+ method: "typia.createAssert",
702
+ path: _path + ".installOtherAppCTAAllowed",
703
+ expected: "boolean",
704
+ value: input.installOtherAppCTAAllowed
705
+ }, _errorFactory)) && ("boolean" === typeof input.requiresStoreReview || _a._assertGuard(_exceptionable, {
706
+ method: "typia.createAssert",
707
+ path: _path + ".requiresStoreReview",
708
+ expected: "boolean",
709
+ value: input.requiresStoreReview
710
+ }, _errorFactory)) && ("boolean" === typeof input.requiresAitReview || _a._assertGuard(_exceptionable, {
711
+ method: "typia.createAssert",
712
+ path: _path + ".requiresAitReview",
713
+ expected: "boolean",
714
+ value: input.requiresAitReview
715
+ }, _errorFactory));
716
+ const _io0 = input => "string" === typeof input.version && ("object" === typeof input.targets && null !== input.targets && false === Array.isArray(input.targets) && _io1(input.targets));
717
+ const _io1 = input => Object.keys(input).every(key => {
718
+ const value = input[key];
719
+ if (undefined === value)
720
+ return true;
721
+ return "object" === typeof value && null !== value && _io2(value);
722
+ });
723
+ const _io2 = input => ("apps-in-toss" === input.runtime || "capacitor-android" === input.runtime || "capacitor-ios" === 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));
724
+ const _io3 = input => _ip0(input) && _ip1(input) && _ip2(input) && "boolean" === typeof input.leaderboard && _ip3(input);
725
+ const _io4 = input => ("local" === input.storage || "native" === input.storage || "none" === input.storage) && _ip3(input);
726
+ const _io5 = input => _ip0(input) && _ip1(input) && _ip2(input);
727
+ const _io6 = input => "boolean" === typeof input.native;
728
+ const _io7 = input => "app-store" === input.profile || "apps-in-toss" === input.profile || "google-play" === input.profile || "web-preview" === input.profile;
729
+ const _io8 = input => "boolean" === typeof input.externalPaymentAllowed && "boolean" === typeof input.remoteExecutableCodeAllowed && "boolean" === typeof input.installOtherAppCTAAllowed && "boolean" === typeof input.requiresStoreReview && "boolean" === typeof input.requiresAitReview;
730
+ const __is = input => "object" === typeof input && null !== input && _io0(input);
731
+ let _errorFactory;
732
+ return (input, errorFactory) => {
733
+ if (false === __is(input)) {
734
+ _errorFactory = errorFactory;
735
+ ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _a._assertGuard(true, {
736
+ method: "typia.createAssert",
737
+ path: _path + "",
738
+ expected: "TargetConfigMatrix",
739
+ value: input
740
+ }, _errorFactory)) && _ao0(input, _path + "", true) || _a._assertGuard(true, {
741
+ method: "typia.createAssert",
742
+ path: _path + "",
743
+ expected: "TargetConfigMatrix",
744
+ value: input
745
+ }, _errorFactory))(input, "$input", true);
746
+ }
747
+ return input;
748
+ };
749
+ })();