@mpgd/target-config 0.5.0 → 0.6.1

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