@mpgd/target-config 0.6.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 (2) hide show
  1. package/dist/index.js +138 -138
  2. package/package.json +7 -7
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,392 +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) && ("en" === input.fallbackLocale || "ko" === input.fallbackLocale || _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
368
  method: "typia.createAssert",
369
369
  path: _path + ".fallbackLocale",
370
370
  expected: "(\"en\" | \"ko\")",
371
371
  value: input.fallbackLocale
372
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 || _a._assertGuard(_exceptionable, {
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, {
374
374
  method: "typia.createAssert",
375
375
  path: _path + ".profile",
376
376
  expected: "(\"app-store\" | \"apps-in-toss\" | \"devvit\" | \"google-play\" | \"microsoft-store\" | \"web-preview\")",
377
377
  value: input.profile
378
378
  }, _errorFactory);
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 || _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, {
380
380
  method: "typia.createAssert",
381
381
  path: _path + ".leaderboard",
382
382
  expected: "boolean",
383
383
  value: input.leaderboard
384
384
  }, _errorFactory)) && _ap4(input, _path, true && _exceptionable);
385
- 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, {
386
386
  method: "typia.createAssert",
387
387
  path: _path + ".storage",
388
388
  expected: "(\"local\" | \"native\" | \"none\")",
389
389
  value: input.storage
390
390
  }, _errorFactory)) && _ap4(input, _path, true && _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 || _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, {
392
392
  method: "typia.createAssert",
393
393
  path: _path + ".identityUpgrade",
394
394
  expected: "(\"approval-required\" | \"available\" | \"configuration-required\" | \"disabled\" | \"unsupported\")",
395
395
  value: input.identityUpgrade
396
- }, _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, {
397
397
  method: "typia.createAssert",
398
398
  path: _path + ".presentation",
399
399
  expected: "(\"approval-required\" | \"available\" | \"configuration-required\" | \"disabled\" | \"unsupported\")",
400
400
  value: input.presentation
401
- }, _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, {
402
402
  method: "typia.createAssert",
403
403
  path: _path + ".sharing",
404
404
  expected: "(\"approval-required\" | \"available\" | \"configuration-required\" | \"disabled\" | \"unsupported\")",
405
405
  value: input.sharing
406
- }, _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, {
407
407
  method: "typia.createAssert",
408
408
  path: _path + ".inboundShare",
409
409
  expected: "(\"approval-required\" | \"available\" | \"configuration-required\" | \"disabled\" | \"unsupported\")",
410
410
  value: input.inboundShare
411
- }, _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, {
412
412
  method: "typia.createAssert",
413
413
  path: _path + ".notifications",
414
414
  expected: "(\"approval-required\" | \"available\" | \"configuration-required\" | \"disabled\" | \"unsupported\")",
415
415
  value: input.notifications
416
- }, _errorFactory)) && ("fullscreen" === input.presentationMode || "inline-expanded" === input.presentationMode || _a._assertGuard(_exceptionable, {
416
+ }, _errorFactory)) && ("fullscreen" === input.presentationMode || "inline-expanded" === input.presentationMode || _assertGuard_1._assertGuard(_exceptionable, {
417
417
  method: "typia.createAssert",
418
418
  path: _path + ".presentationMode",
419
419
  expected: "(\"fullscreen\" | \"inline-expanded\")",
420
420
  value: input.presentationMode
421
421
  }, _errorFactory));
422
- 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, {
423
423
  method: "typia.createAssert",
424
424
  path: _path + ".externalPaymentAllowed",
425
425
  expected: "boolean",
426
426
  value: input.externalPaymentAllowed
427
- }, _errorFactory)) && ("boolean" === typeof input.remoteExecutableCodeAllowed || _a._assertGuard(_exceptionable, {
427
+ }, _errorFactory)) && ("boolean" === typeof input.remoteExecutableCodeAllowed || _assertGuard_1._assertGuard(_exceptionable, {
428
428
  method: "typia.createAssert",
429
429
  path: _path + ".remoteExecutableCodeAllowed",
430
430
  expected: "boolean",
431
431
  value: input.remoteExecutableCodeAllowed
432
- }, _errorFactory)) && ("boolean" === typeof input.installOtherAppCTAAllowed || _a._assertGuard(_exceptionable, {
432
+ }, _errorFactory)) && ("boolean" === typeof input.installOtherAppCTAAllowed || _assertGuard_1._assertGuard(_exceptionable, {
433
433
  method: "typia.createAssert",
434
434
  path: _path + ".installOtherAppCTAAllowed",
435
435
  expected: "boolean",
436
436
  value: input.installOtherAppCTAAllowed
437
- }, _errorFactory)) && ("boolean" === typeof input.requiresStoreReview || _a._assertGuard(_exceptionable, {
437
+ }, _errorFactory)) && ("boolean" === typeof input.requiresStoreReview || _assertGuard_1._assertGuard(_exceptionable, {
438
438
  method: "typia.createAssert",
439
439
  path: _path + ".requiresStoreReview",
440
440
  expected: "boolean",
441
441
  value: input.requiresStoreReview
442
- }, _errorFactory)) && ("boolean" === typeof input.requiresAitReview || _a._assertGuard(_exceptionable, {
442
+ }, _errorFactory)) && ("boolean" === typeof input.requiresAitReview || _assertGuard_1._assertGuard(_exceptionable, {
443
443
  method: "typia.createAssert",
444
444
  path: _path + ".requiresAitReview",
445
445
  expected: "boolean",
446
446
  value: input.requiresAitReview
447
447
  }, _errorFactory));
448
- 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, {
449
449
  method: "typia.createAssert",
450
450
  path: _path + ".targetConfig",
451
451
  expected: "string",
452
452
  value: input.targetConfig
453
- }, _errorFactory)) && ("string" === typeof input.productCatalog || _a._assertGuard(_exceptionable, {
453
+ }, _errorFactory)) && ("string" === typeof input.productCatalog || _assertGuard_1._assertGuard(_exceptionable, {
454
454
  method: "typia.createAssert",
455
455
  path: _path + ".productCatalog",
456
456
  expected: "string",
457
457
  value: input.productCatalog
458
- }, _errorFactory)) && ("string" === typeof input.adPlacements || _a._assertGuard(_exceptionable, {
458
+ }, _errorFactory)) && ("string" === typeof input.adPlacements || _assertGuard_1._assertGuard(_exceptionable, {
459
459
  method: "typia.createAssert",
460
460
  path: _path + ".adPlacements",
461
461
  expected: "string",
462
462
  value: input.adPlacements
463
- }, _errorFactory)) && (undefined === input.platformTargetKind || "string" === typeof input.platformTargetKind || _a._assertGuard(_exceptionable, {
463
+ }, _errorFactory)) && (undefined === input.platformTargetKind || "string" === typeof input.platformTargetKind || _assertGuard_1._assertGuard(_exceptionable, {
464
464
  method: "typia.createAssert",
465
465
  path: _path + ".platformTargetKind",
466
466
  expected: "(string | undefined)",
467
467
  value: input.platformTargetKind
468
- }, _errorFactory)) && (undefined === input.platformAdapter || "string" === typeof input.platformAdapter || _a._assertGuard(_exceptionable, {
468
+ }, _errorFactory)) && (undefined === input.platformAdapter || "string" === typeof input.platformAdapter || _assertGuard_1._assertGuard(_exceptionable, {
469
469
  method: "typia.createAssert",
470
470
  path: _path + ".platformAdapter",
471
471
  expected: "(string | undefined)",
472
472
  value: input.platformAdapter
473
473
  }, _errorFactory));
474
- 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, {
475
475
  method: "typia.createAssert",
476
476
  path: _path + ".products",
477
477
  expected: "ReadonlyArray<EffectiveProductConfig>",
478
478
  value: input.products
479
- }, _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, {
480
480
  method: "typia.createAssert",
481
481
  path: _path + ".products[" + _index3 + "]",
482
482
  expected: "EffectiveProductConfig",
483
483
  value: elem
484
- }, _errorFactory)) && _ao10(elem, _path + ".products[" + _index3 + "]", true && _exceptionable) || _a._assertGuard(_exceptionable, {
484
+ }, _errorFactory)) && _ao10(elem, _path + ".products[" + _index3 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
485
485
  method: "typia.createAssert",
486
486
  path: _path + ".products[" + _index3 + "]",
487
487
  expected: "EffectiveProductConfig",
488
488
  value: elem
489
- }, _errorFactory)) || _a._assertGuard(_exceptionable, {
489
+ }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
490
490
  method: "typia.createAssert",
491
491
  path: _path + ".products",
492
492
  expected: "ReadonlyArray<EffectiveProductConfig>",
@@ -498,7 +498,7 @@ export const assertEffectiveTargetConfigMatrix = (() => {
498
498
  else if ("entitlement" === input.type)
499
499
  return _ao12(input, _path, true && _exceptionable);
500
500
  else
501
- return _a._assertGuard(_exceptionable, {
501
+ return _assertGuard_1._assertGuard(_exceptionable, {
502
502
  method: "typia.createAssert",
503
503
  path: _path,
504
504
  expected: _ae0,
@@ -511,7 +511,7 @@ export const assertEffectiveTargetConfigMatrix = (() => {
511
511
  else if ("currency" === input.type)
512
512
  return _ao16(input, _path, true && _exceptionable);
513
513
  else
514
- return _a._assertGuard(_exceptionable, {
514
+ return _assertGuard_1._assertGuard(_exceptionable, {
515
515
  method: "typia.createAssert",
516
516
  path: _path,
517
517
  expected: _ae2,
@@ -565,12 +565,12 @@ export const assertEffectiveTargetConfigMatrix = (() => {
565
565
  return (input, errorFactory) => {
566
566
  if (false === __is(input)) {
567
567
  _errorFactory = errorFactory;
568
- ((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, {
569
569
  method: "typia.createAssert",
570
570
  path: _path + "",
571
571
  expected: "EffectiveTargetConfigMatrix",
572
572
  value: input
573
- }, _errorFactory)) && _ao0(input, _path + "", true) || _a._assertGuard(true, {
573
+ }, _errorFactory)) && _ao0(input, _path + "", true) || _assertGuard_1._assertGuard(true, {
574
574
  method: "typia.createAssert",
575
575
  path: _path + "",
576
576
  expected: "EffectiveTargetConfigMatrix",
@@ -585,41 +585,41 @@ export const assertTargetConfigMatrix = (() => {
585
585
  const _ip1 = input => "boolean" === typeof input["rewardedAds"];
586
586
  const _ip2 = input => "boolean" === typeof input["interstitialAds"];
587
587
  const _ip3 = input => "boolean" === typeof input["localization"];
588
- 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, {
589
589
  method: "typia.createAssert",
590
590
  path: _path + ".iap",
591
591
  expected: "boolean",
592
592
  value: input["iap"]
593
593
  }, _errorFactory);
594
- 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, {
595
595
  method: "typia.createAssert",
596
596
  path: _path + ".rewardedAds",
597
597
  expected: "boolean",
598
598
  value: input["rewardedAds"]
599
599
  }, _errorFactory);
600
- 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, {
601
601
  method: "typia.createAssert",
602
602
  path: _path + ".interstitialAds",
603
603
  expected: "boolean",
604
604
  value: input["interstitialAds"]
605
605
  }, _errorFactory);
606
- 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, {
607
607
  method: "typia.createAssert",
608
608
  path: _path + ".localization",
609
609
  expected: "boolean",
610
610
  value: input["localization"]
611
611
  }, _errorFactory);
612
- 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, {
613
613
  method: "typia.createAssert",
614
614
  path: _path + ".version",
615
615
  expected: "string",
616
616
  value: input.version
617
- }, _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, {
618
618
  method: "typia.createAssert",
619
619
  path: _path + ".targets",
620
620
  expected: "Record<string, TargetConfig>",
621
621
  value: input.targets
622
- }, _errorFactory)) && _ao1(input.targets, _path + ".targets", true && _exceptionable) || _a._assertGuard(_exceptionable, {
622
+ }, _errorFactory)) && _ao1(input.targets, _path + ".targets", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
623
623
  method: "typia.createAssert",
624
624
  path: _path + ".targets",
625
625
  expected: "Record<string, TargetConfig>",
@@ -629,187 +629,187 @@ export const assertTargetConfigMatrix = (() => {
629
629
  const value = input[key];
630
630
  if (undefined === value)
631
631
  return true;
632
- return ("object" === typeof value && null !== value || _a._assertGuard(_exceptionable, {
632
+ return ("object" === typeof value && null !== value || _assertGuard_1._assertGuard(_exceptionable, {
633
633
  method: "typia.createAssert",
634
634
  path: _path + __typia_transform__accessExpressionAsString(key),
635
635
  expected: "TargetConfig",
636
636
  value: value
637
- }, _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, {
638
638
  method: "typia.createAssert",
639
639
  path: _path + __typia_transform__accessExpressionAsString(key),
640
640
  expected: "TargetConfig",
641
641
  value: value
642
642
  }, _errorFactory);
643
643
  });
644
- const _ao10 = (input, _path, _exceptionable = true) => ("approval-required" === input.identityUpgrade || "available" === input.identityUpgrade || "configuration-required" === input.identityUpgrade || "disabled" === input.identityUpgrade || "unsupported" === input.identityUpgrade || _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
645
  method: "typia.createAssert",
646
646
  path: _path + ".identityUpgrade",
647
647
  expected: "(\"approval-required\" | \"available\" | \"configuration-required\" | \"disabled\" | \"unsupported\")",
648
648
  value: input.identityUpgrade
649
- }, _errorFactory)) && ("approval-required" === input.presentation || "available" === input.presentation || "configuration-required" === input.presentation || "disabled" === input.presentation || "unsupported" === input.presentation || _a._assertGuard(_exceptionable, {
649
+ }, _errorFactory)) && ("approval-required" === input.presentation || "available" === input.presentation || "configuration-required" === input.presentation || "disabled" === input.presentation || "unsupported" === input.presentation || _assertGuard_1._assertGuard(_exceptionable, {
650
650
  method: "typia.createAssert",
651
651
  path: _path + ".presentation",
652
652
  expected: "(\"approval-required\" | \"available\" | \"configuration-required\" | \"disabled\" | \"unsupported\")",
653
653
  value: input.presentation
654
- }, _errorFactory)) && ("approval-required" === input.sharing || "available" === input.sharing || "configuration-required" === input.sharing || "disabled" === input.sharing || "unsupported" === input.sharing || _a._assertGuard(_exceptionable, {
654
+ }, _errorFactory)) && ("approval-required" === input.sharing || "available" === input.sharing || "configuration-required" === input.sharing || "disabled" === input.sharing || "unsupported" === input.sharing || _assertGuard_1._assertGuard(_exceptionable, {
655
655
  method: "typia.createAssert",
656
656
  path: _path + ".sharing",
657
657
  expected: "(\"approval-required\" | \"available\" | \"configuration-required\" | \"disabled\" | \"unsupported\")",
658
658
  value: input.sharing
659
- }, _errorFactory)) && ("approval-required" === input.inboundShare || "available" === input.inboundShare || "configuration-required" === input.inboundShare || "disabled" === input.inboundShare || "unsupported" === input.inboundShare || _a._assertGuard(_exceptionable, {
659
+ }, _errorFactory)) && ("approval-required" === input.inboundShare || "available" === input.inboundShare || "configuration-required" === input.inboundShare || "disabled" === input.inboundShare || "unsupported" === input.inboundShare || _assertGuard_1._assertGuard(_exceptionable, {
660
660
  method: "typia.createAssert",
661
661
  path: _path + ".inboundShare",
662
662
  expected: "(\"approval-required\" | \"available\" | \"configuration-required\" | \"disabled\" | \"unsupported\")",
663
663
  value: input.inboundShare
664
- }, _errorFactory)) && ("approval-required" === input.notifications || "available" === input.notifications || "configuration-required" === input.notifications || "disabled" === input.notifications || "unsupported" === input.notifications || _a._assertGuard(_exceptionable, {
664
+ }, _errorFactory)) && ("approval-required" === input.notifications || "available" === input.notifications || "configuration-required" === input.notifications || "disabled" === input.notifications || "unsupported" === input.notifications || _assertGuard_1._assertGuard(_exceptionable, {
665
665
  method: "typia.createAssert",
666
666
  path: _path + ".notifications",
667
667
  expected: "(\"approval-required\" | \"available\" | \"configuration-required\" | \"disabled\" | \"unsupported\")",
668
668
  value: input.notifications
669
- }, _errorFactory)) && ("fullscreen" === input.presentationMode || "inline-expanded" === input.presentationMode || _a._assertGuard(_exceptionable, {
669
+ }, _errorFactory)) && ("fullscreen" === input.presentationMode || "inline-expanded" === input.presentationMode || _assertGuard_1._assertGuard(_exceptionable, {
670
670
  method: "typia.createAssert",
671
671
  path: _path + ".presentationMode",
672
672
  expected: "(\"fullscreen\" | \"inline-expanded\")",
673
673
  value: input.presentationMode
674
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 || _a._assertGuard(_exceptionable, {
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, {
676
676
  method: "typia.createAssert",
677
677
  path: _path + ".runtime",
678
678
  expected: "(\"apps-in-toss\" | \"capacitor-android\" | \"capacitor-ios\" | \"devvit-web\" | \"microsoft-store-pwa\" | \"web-preview\")",
679
679
  value: input.runtime
680
- }, _errorFactory)) && (("object" === typeof input.features && null !== input.features || _a._assertGuard(_exceptionable, {
680
+ }, _errorFactory)) && (("object" === typeof input.features && null !== input.features || _assertGuard_1._assertGuard(_exceptionable, {
681
681
  method: "typia.createAssert",
682
682
  path: _path + ".features",
683
683
  expected: "TargetFeatureConfig",
684
684
  value: input.features
685
- }, _errorFactory)) && _ao3(input.features, _path + ".features", true && _exceptionable) || _a._assertGuard(_exceptionable, {
685
+ }, _errorFactory)) && _ao3(input.features, _path + ".features", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
686
686
  method: "typia.createAssert",
687
687
  path: _path + ".features",
688
688
  expected: "TargetFeatureConfig",
689
689
  value: input.features
690
- }, _errorFactory)) && (("object" === typeof input.capabilities && null !== input.capabilities || _a._assertGuard(_exceptionable, {
690
+ }, _errorFactory)) && (("object" === typeof input.capabilities && null !== input.capabilities || _assertGuard_1._assertGuard(_exceptionable, {
691
691
  method: "typia.createAssert",
692
692
  path: _path + ".capabilities",
693
693
  expected: "TargetCapabilityConfig",
694
694
  value: input.capabilities
695
- }, _errorFactory)) && _ao4(input.capabilities, _path + ".capabilities", true && _exceptionable) || _a._assertGuard(_exceptionable, {
695
+ }, _errorFactory)) && _ao4(input.capabilities, _path + ".capabilities", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
696
696
  method: "typia.createAssert",
697
697
  path: _path + ".capabilities",
698
698
  expected: "TargetCapabilityConfig",
699
699
  value: input.capabilities
700
- }, _errorFactory)) && (("object" === typeof input.localization && null !== input.localization || _a._assertGuard(_exceptionable, {
700
+ }, _errorFactory)) && (("object" === typeof input.localization && null !== input.localization || _assertGuard_1._assertGuard(_exceptionable, {
701
701
  method: "typia.createAssert",
702
702
  path: _path + ".localization",
703
703
  expected: "TargetLocalizationConfig",
704
704
  value: input.localization
705
- }, _errorFactory)) && _ao5(input.localization, _path + ".localization", true && _exceptionable) || _a._assertGuard(_exceptionable, {
705
+ }, _errorFactory)) && _ao5(input.localization, _path + ".localization", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
706
706
  method: "typia.createAssert",
707
707
  path: _path + ".localization",
708
708
  expected: "TargetLocalizationConfig",
709
709
  value: input.localization
710
- }, _errorFactory)) && (("object" === typeof input.monetization && null !== input.monetization || _a._assertGuard(_exceptionable, {
710
+ }, _errorFactory)) && (("object" === typeof input.monetization && null !== input.monetization || _assertGuard_1._assertGuard(_exceptionable, {
711
711
  method: "typia.createAssert",
712
712
  path: _path + ".monetization",
713
713
  expected: "TargetMonetizationConfig",
714
714
  value: input.monetization
715
- }, _errorFactory)) && _ao6(input.monetization, _path + ".monetization", true && _exceptionable) || _a._assertGuard(_exceptionable, {
715
+ }, _errorFactory)) && _ao6(input.monetization, _path + ".monetization", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
716
716
  method: "typia.createAssert",
717
717
  path: _path + ".monetization",
718
718
  expected: "TargetMonetizationConfig",
719
719
  value: input.monetization
720
- }, _errorFactory)) && (("object" === typeof input.leaderboard && null !== input.leaderboard || _a._assertGuard(_exceptionable, {
720
+ }, _errorFactory)) && (("object" === typeof input.leaderboard && null !== input.leaderboard || _assertGuard_1._assertGuard(_exceptionable, {
721
721
  method: "typia.createAssert",
722
722
  path: _path + ".leaderboard",
723
723
  expected: "TargetLeaderboardConfig",
724
724
  value: input.leaderboard
725
- }, _errorFactory)) && _ao7(input.leaderboard, _path + ".leaderboard", true && _exceptionable) || _a._assertGuard(_exceptionable, {
725
+ }, _errorFactory)) && _ao7(input.leaderboard, _path + ".leaderboard", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
726
726
  method: "typia.createAssert",
727
727
  path: _path + ".leaderboard",
728
728
  expected: "TargetLeaderboardConfig",
729
729
  value: input.leaderboard
730
- }, _errorFactory)) && (("object" === typeof input.release && null !== input.release || _a._assertGuard(_exceptionable, {
730
+ }, _errorFactory)) && (("object" === typeof input.release && null !== input.release || _assertGuard_1._assertGuard(_exceptionable, {
731
731
  method: "typia.createAssert",
732
732
  path: _path + ".release",
733
733
  expected: "TargetReleaseConfig",
734
734
  value: input.release
735
- }, _errorFactory)) && _ao8(input.release, _path + ".release", true && _exceptionable) || _a._assertGuard(_exceptionable, {
735
+ }, _errorFactory)) && _ao8(input.release, _path + ".release", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
736
736
  method: "typia.createAssert",
737
737
  path: _path + ".release",
738
738
  expected: "TargetReleaseConfig",
739
739
  value: input.release
740
- }, _errorFactory)) && (("object" === typeof input.policy && null !== input.policy || _a._assertGuard(_exceptionable, {
740
+ }, _errorFactory)) && (("object" === typeof input.policy && null !== input.policy || _assertGuard_1._assertGuard(_exceptionable, {
741
741
  method: "typia.createAssert",
742
742
  path: _path + ".policy",
743
743
  expected: "TargetPolicyRestrictions",
744
744
  value: input.policy
745
- }, _errorFactory)) && _ao9(input.policy, _path + ".policy", true && _exceptionable) || _a._assertGuard(_exceptionable, {
745
+ }, _errorFactory)) && _ao9(input.policy, _path + ".policy", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
746
746
  method: "typia.createAssert",
747
747
  path: _path + ".policy",
748
748
  expected: "TargetPolicyRestrictions",
749
749
  value: input.policy
750
- }, _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, {
751
751
  method: "typia.createAssert",
752
752
  path: _path + ".integrations",
753
753
  expected: "(TargetIntegrationConfig | undefined)",
754
754
  value: input.integrations
755
- }, _errorFactory)) && _ao10(input.integrations, _path + ".integrations", true && _exceptionable) || _a._assertGuard(_exceptionable, {
755
+ }, _errorFactory)) && _ao10(input.integrations, _path + ".integrations", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
756
756
  method: "typia.createAssert",
757
757
  path: _path + ".integrations",
758
758
  expected: "(TargetIntegrationConfig | undefined)",
759
759
  value: input.integrations
760
760
  }, _errorFactory));
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 || _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, {
762
762
  method: "typia.createAssert",
763
763
  path: _path + ".leaderboard",
764
764
  expected: "boolean",
765
765
  value: input.leaderboard
766
766
  }, _errorFactory)) && _ap3(input, _path, true && _exceptionable);
767
- 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, {
768
768
  method: "typia.createAssert",
769
769
  path: _path + ".storage",
770
770
  expected: "(\"local\" | \"native\" | \"none\")",
771
771
  value: input.storage
772
772
  }, _errorFactory)) && _ap3(input, _path, true && _exceptionable);
773
- const _ao5 = (input, _path, _exceptionable = true) => "en" === input.fallbackLocale || "ko" === input.fallbackLocale || _a._assertGuard(_exceptionable, {
773
+ const _ao5 = (input, _path, _exceptionable = true) => "en" === input.fallbackLocale || "ko" === input.fallbackLocale || _assertGuard_1._assertGuard(_exceptionable, {
774
774
  method: "typia.createAssert",
775
775
  path: _path + ".fallbackLocale",
776
776
  expected: "(\"en\" | \"ko\")",
777
777
  value: input.fallbackLocale
778
778
  }, _errorFactory);
779
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 || _a._assertGuard(_exceptionable, {
780
+ const _ao7 = (input, _path, _exceptionable = true) => "boolean" === typeof input.native || _assertGuard_1._assertGuard(_exceptionable, {
781
781
  method: "typia.createAssert",
782
782
  path: _path + ".native",
783
783
  expected: "boolean",
784
784
  value: input.native
785
785
  }, _errorFactory);
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 || _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, {
787
787
  method: "typia.createAssert",
788
788
  path: _path + ".profile",
789
789
  expected: "(\"app-store\" | \"apps-in-toss\" | \"devvit\" | \"google-play\" | \"microsoft-store\" | \"web-preview\")",
790
790
  value: input.profile
791
791
  }, _errorFactory);
792
- const _ao9 = (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, {
793
793
  method: "typia.createAssert",
794
794
  path: _path + ".externalPaymentAllowed",
795
795
  expected: "boolean",
796
796
  value: input.externalPaymentAllowed
797
- }, _errorFactory)) && ("boolean" === typeof input.remoteExecutableCodeAllowed || _a._assertGuard(_exceptionable, {
797
+ }, _errorFactory)) && ("boolean" === typeof input.remoteExecutableCodeAllowed || _assertGuard_1._assertGuard(_exceptionable, {
798
798
  method: "typia.createAssert",
799
799
  path: _path + ".remoteExecutableCodeAllowed",
800
800
  expected: "boolean",
801
801
  value: input.remoteExecutableCodeAllowed
802
- }, _errorFactory)) && ("boolean" === typeof input.installOtherAppCTAAllowed || _a._assertGuard(_exceptionable, {
802
+ }, _errorFactory)) && ("boolean" === typeof input.installOtherAppCTAAllowed || _assertGuard_1._assertGuard(_exceptionable, {
803
803
  method: "typia.createAssert",
804
804
  path: _path + ".installOtherAppCTAAllowed",
805
805
  expected: "boolean",
806
806
  value: input.installOtherAppCTAAllowed
807
- }, _errorFactory)) && ("boolean" === typeof input.requiresStoreReview || _a._assertGuard(_exceptionable, {
807
+ }, _errorFactory)) && ("boolean" === typeof input.requiresStoreReview || _assertGuard_1._assertGuard(_exceptionable, {
808
808
  method: "typia.createAssert",
809
809
  path: _path + ".requiresStoreReview",
810
810
  expected: "boolean",
811
811
  value: input.requiresStoreReview
812
- }, _errorFactory)) && ("boolean" === typeof input.requiresAitReview || _a._assertGuard(_exceptionable, {
812
+ }, _errorFactory)) && ("boolean" === typeof input.requiresAitReview || _assertGuard_1._assertGuard(_exceptionable, {
813
813
  method: "typia.createAssert",
814
814
  path: _path + ".requiresAitReview",
815
815
  expected: "boolean",
@@ -836,12 +836,12 @@ export const assertTargetConfigMatrix = (() => {
836
836
  return (input, errorFactory) => {
837
837
  if (false === __is(input)) {
838
838
  _errorFactory = errorFactory;
839
- ((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, {
840
840
  method: "typia.createAssert",
841
841
  path: _path + "",
842
842
  expected: "TargetConfigMatrix",
843
843
  value: input
844
- }, _errorFactory)) && _ao0(input, _path + "", true) || _a._assertGuard(true, {
844
+ }, _errorFactory)) && _ao0(input, _path + "", true) || _assertGuard_1._assertGuard(true, {
845
845
  method: "typia.createAssert",
846
846
  path: _path + "",
847
847
  expected: "TargetConfigMatrix",
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@mpgd/target-config",
3
- "version": "0.6.0",
3
+ "version": "0.6.1",
4
4
  "description": "Target-specific platform feature availability and effective config helpers for mpgd.",
5
5
  "license": "MIT",
6
6
  "repository": {
@@ -36,14 +36,14 @@
36
36
  "targets.json"
37
37
  ],
38
38
  "dependencies": {
39
- "typia": "rc",
40
- "@mpgd/i18n": "0.5.0",
41
- "@mpgd/platform": "0.5.0",
42
- "@mpgd/catalog": "0.3.4"
39
+ "typia": "13.0.2",
40
+ "@mpgd/catalog": "0.3.5",
41
+ "@mpgd/i18n": "0.5.1",
42
+ "@mpgd/platform": "0.5.1"
43
43
  },
44
44
  "devDependencies": {
45
- "ttsc": "0.16.9",
46
- "typescript": "7.0.1-rc"
45
+ "ttsc": "0.18.4",
46
+ "typescript": "7.0.2"
47
47
  },
48
48
  "main": "./dist/index.js",
49
49
  "types": "./dist/index.d.ts",