@mpgd/catalog 0.3.4 → 0.3.5

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 +57 -57
  2. package/package.json +5 -5
package/dist/index.js CHANGED
@@ -1,102 +1,102 @@
1
- import * as _a from "typia/lib/internal/_assertGuard";
1
+ import * as _assertGuard_1 from "typia/lib/internal/_assertGuard";
2
2
  import typia from 'typia';
3
3
  export const assertProductCatalog = (() => {
4
4
  const _ae0 = "({ readonly type: \"currency\"; readonly currency: \"coin\" | \"gem\"; readonly amount: number; } | { readonly type: \"entitlement\"; readonly entitlement: string; })";
5
- const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.version || _a._assertGuard(_exceptionable, {
5
+ const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.version || _assertGuard_1._assertGuard(_exceptionable, {
6
6
  method: "typia.createAssert",
7
7
  path: _path + ".version",
8
8
  expected: "string",
9
9
  value: input.version
10
- }, _errorFactory)) && ((Array.isArray(input.products) || _a._assertGuard(_exceptionable, {
10
+ }, _errorFactory)) && ((Array.isArray(input.products) || _assertGuard_1._assertGuard(_exceptionable, {
11
11
  method: "typia.createAssert",
12
12
  path: _path + ".products",
13
13
  expected: "ReadonlyArray<ProductCatalogEntry>",
14
14
  value: input.products
15
- }, _errorFactory)) && input.products.every((elem, _index2) => ("object" === typeof elem && null !== elem || _a._assertGuard(_exceptionable, {
15
+ }, _errorFactory)) && input.products.every((elem, _index2) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
16
16
  method: "typia.createAssert",
17
17
  path: _path + ".products[" + _index2 + "]",
18
18
  expected: "ProductCatalogEntry",
19
19
  value: elem
20
- }, _errorFactory)) && _ao1(elem, _path + ".products[" + _index2 + "]", true && _exceptionable) || _a._assertGuard(_exceptionable, {
20
+ }, _errorFactory)) && _ao1(elem, _path + ".products[" + _index2 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
21
21
  method: "typia.createAssert",
22
22
  path: _path + ".products[" + _index2 + "]",
23
23
  expected: "ProductCatalogEntry",
24
24
  value: elem
25
- }, _errorFactory)) || _a._assertGuard(_exceptionable, {
25
+ }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
26
26
  method: "typia.createAssert",
27
27
  path: _path + ".products",
28
28
  expected: "ReadonlyArray<ProductCatalogEntry>",
29
29
  value: input.products
30
30
  }, _errorFactory));
31
- const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || _a._assertGuard(_exceptionable, {
31
+ const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || _assertGuard_1._assertGuard(_exceptionable, {
32
32
  method: "typia.createAssert",
33
33
  path: _path + ".id",
34
34
  expected: "string",
35
35
  value: input.id
36
- }, _errorFactory)) && ("consumable" === input.type || "non_consumable" === input.type || "subscription" === input.type || _a._assertGuard(_exceptionable, {
36
+ }, _errorFactory)) && ("consumable" === input.type || "non_consumable" === input.type || "subscription" === input.type || _assertGuard_1._assertGuard(_exceptionable, {
37
37
  method: "typia.createAssert",
38
38
  path: _path + ".type",
39
39
  expected: "(\"consumable\" | \"non_consumable\" | \"subscription\")",
40
40
  value: input.type
41
- }, _errorFactory)) && (("object" === typeof input.grant && null !== input.grant || _a._assertGuard(_exceptionable, {
41
+ }, _errorFactory)) && (("object" === typeof input.grant && null !== input.grant || _assertGuard_1._assertGuard(_exceptionable, {
42
42
  method: "typia.createAssert",
43
43
  path: _path + ".grant",
44
44
  expected: _ae0,
45
45
  value: input.grant
46
- }, _errorFactory)) && _au0(input.grant, _path + ".grant", true && _exceptionable) || _a._assertGuard(_exceptionable, {
46
+ }, _errorFactory)) && _au0(input.grant, _path + ".grant", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
47
47
  method: "typia.createAssert",
48
48
  path: _path + ".grant",
49
49
  expected: _ae0,
50
50
  value: input.grant
51
- }, _errorFactory)) && (("object" === typeof input.platformProductIds && null !== input.platformProductIds && false === Array.isArray(input.platformProductIds) || _a._assertGuard(_exceptionable, {
51
+ }, _errorFactory)) && (("object" === typeof input.platformProductIds && null !== input.platformProductIds && false === Array.isArray(input.platformProductIds) || _assertGuard_1._assertGuard(_exceptionable, {
52
52
  method: "typia.createAssert",
53
53
  path: _path + ".platformProductIds",
54
54
  expected: "Partial<Record<CatalogTarget, string>>",
55
55
  value: input.platformProductIds
56
- }, _errorFactory)) && _ao4(input.platformProductIds, _path + ".platformProductIds", true && _exceptionable) || _a._assertGuard(_exceptionable, {
56
+ }, _errorFactory)) && _ao4(input.platformProductIds, _path + ".platformProductIds", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
57
57
  method: "typia.createAssert",
58
58
  path: _path + ".platformProductIds",
59
59
  expected: "Partial<Record<CatalogTarget, string>>",
60
60
  value: input.platformProductIds
61
61
  }, _errorFactory));
62
- const _ao2 = (input, _path, _exceptionable = true) => ("currency" === input.type || _a._assertGuard(_exceptionable, {
62
+ const _ao2 = (input, _path, _exceptionable = true) => ("currency" === input.type || _assertGuard_1._assertGuard(_exceptionable, {
63
63
  method: "typia.createAssert",
64
64
  path: _path + ".type",
65
65
  expected: "\"currency\"",
66
66
  value: input.type
67
- }, _errorFactory)) && ("coin" === input.currency || "gem" === input.currency || _a._assertGuard(_exceptionable, {
67
+ }, _errorFactory)) && ("coin" === input.currency || "gem" === input.currency || _assertGuard_1._assertGuard(_exceptionable, {
68
68
  method: "typia.createAssert",
69
69
  path: _path + ".currency",
70
70
  expected: "(\"coin\" | \"gem\")",
71
71
  value: input.currency
72
- }, _errorFactory)) && ("number" === typeof input.amount || _a._assertGuard(_exceptionable, {
72
+ }, _errorFactory)) && ("number" === typeof input.amount || _assertGuard_1._assertGuard(_exceptionable, {
73
73
  method: "typia.createAssert",
74
74
  path: _path + ".amount",
75
75
  expected: "number",
76
76
  value: input.amount
77
77
  }, _errorFactory));
78
- const _ao3 = (input, _path, _exceptionable = true) => ("entitlement" === input.type || _a._assertGuard(_exceptionable, {
78
+ const _ao3 = (input, _path, _exceptionable = true) => ("entitlement" === input.type || _assertGuard_1._assertGuard(_exceptionable, {
79
79
  method: "typia.createAssert",
80
80
  path: _path + ".type",
81
81
  expected: "\"entitlement\"",
82
82
  value: input.type
83
- }, _errorFactory)) && ("string" === typeof input.entitlement || _a._assertGuard(_exceptionable, {
83
+ }, _errorFactory)) && ("string" === typeof input.entitlement || _assertGuard_1._assertGuard(_exceptionable, {
84
84
  method: "typia.createAssert",
85
85
  path: _path + ".entitlement",
86
86
  expected: "string",
87
87
  value: input.entitlement
88
88
  }, _errorFactory));
89
- const _ao4 = (input, _path, _exceptionable = true) => (undefined === input.ait || "string" === typeof input.ait || _a._assertGuard(_exceptionable, {
89
+ const _ao4 = (input, _path, _exceptionable = true) => (undefined === input.ait || "string" === typeof input.ait || _assertGuard_1._assertGuard(_exceptionable, {
90
90
  method: "typia.createAssert",
91
91
  path: _path + ".ait",
92
92
  expected: "(string | undefined)",
93
93
  value: input.ait
94
- }, _errorFactory)) && (undefined === input.android || "string" === typeof input.android || _a._assertGuard(_exceptionable, {
94
+ }, _errorFactory)) && (undefined === input.android || "string" === typeof input.android || _assertGuard_1._assertGuard(_exceptionable, {
95
95
  method: "typia.createAssert",
96
96
  path: _path + ".android",
97
97
  expected: "(string | undefined)",
98
98
  value: input.android
99
- }, _errorFactory)) && (undefined === input.ios || "string" === typeof input.ios || _a._assertGuard(_exceptionable, {
99
+ }, _errorFactory)) && (undefined === input.ios || "string" === typeof input.ios || _assertGuard_1._assertGuard(_exceptionable, {
100
100
  method: "typia.createAssert",
101
101
  path: _path + ".ios",
102
102
  expected: "(string | undefined)",
@@ -108,7 +108,7 @@ export const assertProductCatalog = (() => {
108
108
  else if ("entitlement" === input.type)
109
109
  return _ao3(input, _path, true && _exceptionable);
110
110
  else
111
- return _a._assertGuard(_exceptionable, {
111
+ return _assertGuard_1._assertGuard(_exceptionable, {
112
112
  method: "typia.createAssert",
113
113
  path: _path,
114
114
  expected: _ae0,
@@ -133,12 +133,12 @@ export const assertProductCatalog = (() => {
133
133
  return (input, errorFactory) => {
134
134
  if (false === __is(input)) {
135
135
  _errorFactory = errorFactory;
136
- ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _a._assertGuard(true, {
136
+ ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _assertGuard_1._assertGuard(true, {
137
137
  method: "typia.createAssert",
138
138
  path: _path + "",
139
139
  expected: "ProductCatalog",
140
140
  value: input
141
- }, _errorFactory)) && _ao0(input, _path + "", true) || _a._assertGuard(true, {
141
+ }, _errorFactory)) && _ao0(input, _path + "", true) || _assertGuard_1._assertGuard(true, {
142
142
  method: "typia.createAssert",
143
143
  path: _path + "",
144
144
  expected: "ProductCatalog",
@@ -151,124 +151,124 @@ export const assertProductCatalog = (() => {
151
151
  export const assertAdPlacements = (() => {
152
152
  const _ip0 = input => "number" === typeof input["amount"];
153
153
  const _ae0 = "(undefined | { readonly type: \"continue\"; readonly amount: number; } | { readonly type: \"currency\"; readonly amount: number; readonly currency: \"coin\" | \"gem\"; })";
154
- const _ap0 = (input, _path, _exceptionable = true) => "number" === typeof input["amount"] || _a._assertGuard(_exceptionable, {
154
+ const _ap0 = (input, _path, _exceptionable = true) => "number" === typeof input["amount"] || _assertGuard_1._assertGuard(_exceptionable, {
155
155
  method: "typia.createAssert",
156
156
  path: _path + ".amount",
157
157
  expected: "number",
158
158
  value: input["amount"]
159
159
  }, _errorFactory);
160
160
  const _ae1 = "({ readonly type: \"continue\"; readonly amount: number; } | { readonly type: \"currency\"; readonly amount: number; readonly currency: \"coin\" | \"gem\"; })";
161
- const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.version || _a._assertGuard(_exceptionable, {
161
+ const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.version || _assertGuard_1._assertGuard(_exceptionable, {
162
162
  method: "typia.createAssert",
163
163
  path: _path + ".version",
164
164
  expected: "string",
165
165
  value: input.version
166
- }, _errorFactory)) && ((Array.isArray(input.placements) || _a._assertGuard(_exceptionable, {
166
+ }, _errorFactory)) && ((Array.isArray(input.placements) || _assertGuard_1._assertGuard(_exceptionable, {
167
167
  method: "typia.createAssert",
168
168
  path: _path + ".placements",
169
169
  expected: "ReadonlyArray<AdPlacementEntry>",
170
170
  value: input.placements
171
- }, _errorFactory)) && input.placements.every((elem, _index2) => ("object" === typeof elem && null !== elem || _a._assertGuard(_exceptionable, {
171
+ }, _errorFactory)) && input.placements.every((elem, _index2) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
172
172
  method: "typia.createAssert",
173
173
  path: _path + ".placements[" + _index2 + "]",
174
174
  expected: "AdPlacementEntry",
175
175
  value: elem
176
- }, _errorFactory)) && _ao1(elem, _path + ".placements[" + _index2 + "]", true && _exceptionable) || _a._assertGuard(_exceptionable, {
176
+ }, _errorFactory)) && _ao1(elem, _path + ".placements[" + _index2 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
177
177
  method: "typia.createAssert",
178
178
  path: _path + ".placements[" + _index2 + "]",
179
179
  expected: "AdPlacementEntry",
180
180
  value: elem
181
- }, _errorFactory)) || _a._assertGuard(_exceptionable, {
181
+ }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
182
182
  method: "typia.createAssert",
183
183
  path: _path + ".placements",
184
184
  expected: "ReadonlyArray<AdPlacementEntry>",
185
185
  value: input.placements
186
186
  }, _errorFactory));
187
- const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || _a._assertGuard(_exceptionable, {
187
+ const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || _assertGuard_1._assertGuard(_exceptionable, {
188
188
  method: "typia.createAssert",
189
189
  path: _path + ".id",
190
190
  expected: "string",
191
191
  value: input.id
192
- }, _errorFactory)) && ("interstitial" === input.type || "rewarded" === input.type || _a._assertGuard(_exceptionable, {
192
+ }, _errorFactory)) && ("interstitial" === input.type || "rewarded" === input.type || _assertGuard_1._assertGuard(_exceptionable, {
193
193
  method: "typia.createAssert",
194
194
  path: _path + ".type",
195
195
  expected: "(\"interstitial\" | \"rewarded\")",
196
196
  value: input.type
197
- }, _errorFactory)) && (undefined === input.reward || ("object" === typeof input.reward && null !== input.reward || _a._assertGuard(_exceptionable, {
197
+ }, _errorFactory)) && (undefined === input.reward || ("object" === typeof input.reward && null !== input.reward || _assertGuard_1._assertGuard(_exceptionable, {
198
198
  method: "typia.createAssert",
199
199
  path: _path + ".reward",
200
200
  expected: _ae0,
201
201
  value: input.reward
202
- }, _errorFactory)) && _au0(input.reward, _path + ".reward", true && _exceptionable) || _a._assertGuard(_exceptionable, {
202
+ }, _errorFactory)) && _au0(input.reward, _path + ".reward", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
203
203
  method: "typia.createAssert",
204
204
  path: _path + ".reward",
205
205
  expected: _ae0,
206
206
  value: input.reward
207
- }, _errorFactory)) && (("object" === typeof input.frequencyCap && null !== input.frequencyCap || _a._assertGuard(_exceptionable, {
207
+ }, _errorFactory)) && (("object" === typeof input.frequencyCap && null !== input.frequencyCap || _assertGuard_1._assertGuard(_exceptionable, {
208
208
  method: "typia.createAssert",
209
209
  path: _path + ".frequencyCap",
210
210
  expected: "FrequencyCap",
211
211
  value: input.frequencyCap
212
- }, _errorFactory)) && _ao4(input.frequencyCap, _path + ".frequencyCap", true && _exceptionable) || _a._assertGuard(_exceptionable, {
212
+ }, _errorFactory)) && _ao4(input.frequencyCap, _path + ".frequencyCap", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
213
213
  method: "typia.createAssert",
214
214
  path: _path + ".frequencyCap",
215
215
  expected: "FrequencyCap",
216
216
  value: input.frequencyCap
217
- }, _errorFactory)) && (("object" === typeof input.platformPlacementIds && null !== input.platformPlacementIds && false === Array.isArray(input.platformPlacementIds) || _a._assertGuard(_exceptionable, {
217
+ }, _errorFactory)) && (("object" === typeof input.platformPlacementIds && null !== input.platformPlacementIds && false === Array.isArray(input.platformPlacementIds) || _assertGuard_1._assertGuard(_exceptionable, {
218
218
  method: "typia.createAssert",
219
219
  path: _path + ".platformPlacementIds",
220
220
  expected: "Partial<Record<CatalogTarget, string>>",
221
221
  value: input.platformPlacementIds
222
- }, _errorFactory)) && _ao5(input.platformPlacementIds, _path + ".platformPlacementIds", true && _exceptionable) || _a._assertGuard(_exceptionable, {
222
+ }, _errorFactory)) && _ao5(input.platformPlacementIds, _path + ".platformPlacementIds", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
223
223
  method: "typia.createAssert",
224
224
  path: _path + ".platformPlacementIds",
225
225
  expected: "Partial<Record<CatalogTarget, string>>",
226
226
  value: input.platformPlacementIds
227
227
  }, _errorFactory));
228
- const _ao2 = (input, _path, _exceptionable = true) => ("continue" === input.type || _a._assertGuard(_exceptionable, {
228
+ const _ao2 = (input, _path, _exceptionable = true) => ("continue" === input.type || _assertGuard_1._assertGuard(_exceptionable, {
229
229
  method: "typia.createAssert",
230
230
  path: _path + ".type",
231
231
  expected: "\"continue\"",
232
232
  value: input.type
233
233
  }, _errorFactory)) && _ap0(input, _path, true && _exceptionable);
234
- const _ao3 = (input, _path, _exceptionable = true) => ("currency" === input.type || _a._assertGuard(_exceptionable, {
234
+ const _ao3 = (input, _path, _exceptionable = true) => ("currency" === input.type || _assertGuard_1._assertGuard(_exceptionable, {
235
235
  method: "typia.createAssert",
236
236
  path: _path + ".type",
237
237
  expected: "\"currency\"",
238
238
  value: input.type
239
- }, _errorFactory)) && _ap0(input, _path, true && _exceptionable) && ("coin" === input.currency || "gem" === input.currency || _a._assertGuard(_exceptionable, {
239
+ }, _errorFactory)) && _ap0(input, _path, true && _exceptionable) && ("coin" === input.currency || "gem" === input.currency || _assertGuard_1._assertGuard(_exceptionable, {
240
240
  method: "typia.createAssert",
241
241
  path: _path + ".currency",
242
242
  expected: "(\"coin\" | \"gem\")",
243
243
  value: input.currency
244
244
  }, _errorFactory));
245
- const _ao4 = (input, _path, _exceptionable = true) => ("number" === typeof input.cooldownSeconds || _a._assertGuard(_exceptionable, {
245
+ const _ao4 = (input, _path, _exceptionable = true) => ("number" === typeof input.cooldownSeconds || _assertGuard_1._assertGuard(_exceptionable, {
246
246
  method: "typia.createAssert",
247
247
  path: _path + ".cooldownSeconds",
248
248
  expected: "number",
249
249
  value: input.cooldownSeconds
250
- }, _errorFactory)) && (undefined === input.maxPerSession || "number" === typeof input.maxPerSession || _a._assertGuard(_exceptionable, {
250
+ }, _errorFactory)) && (undefined === input.maxPerSession || "number" === typeof input.maxPerSession || _assertGuard_1._assertGuard(_exceptionable, {
251
251
  method: "typia.createAssert",
252
252
  path: _path + ".maxPerSession",
253
253
  expected: "(number | undefined)",
254
254
  value: input.maxPerSession
255
- }, _errorFactory)) && (undefined === input.minStageInterval || "number" === typeof input.minStageInterval || _a._assertGuard(_exceptionable, {
255
+ }, _errorFactory)) && (undefined === input.minStageInterval || "number" === typeof input.minStageInterval || _assertGuard_1._assertGuard(_exceptionable, {
256
256
  method: "typia.createAssert",
257
257
  path: _path + ".minStageInterval",
258
258
  expected: "(number | undefined)",
259
259
  value: input.minStageInterval
260
260
  }, _errorFactory));
261
- const _ao5 = (input, _path, _exceptionable = true) => (undefined === input.ait || "string" === typeof input.ait || _a._assertGuard(_exceptionable, {
261
+ const _ao5 = (input, _path, _exceptionable = true) => (undefined === input.ait || "string" === typeof input.ait || _assertGuard_1._assertGuard(_exceptionable, {
262
262
  method: "typia.createAssert",
263
263
  path: _path + ".ait",
264
264
  expected: "(string | undefined)",
265
265
  value: input.ait
266
- }, _errorFactory)) && (undefined === input.android || "string" === typeof input.android || _a._assertGuard(_exceptionable, {
266
+ }, _errorFactory)) && (undefined === input.android || "string" === typeof input.android || _assertGuard_1._assertGuard(_exceptionable, {
267
267
  method: "typia.createAssert",
268
268
  path: _path + ".android",
269
269
  expected: "(string | undefined)",
270
270
  value: input.android
271
- }, _errorFactory)) && (undefined === input.ios || "string" === typeof input.ios || _a._assertGuard(_exceptionable, {
271
+ }, _errorFactory)) && (undefined === input.ios || "string" === typeof input.ios || _assertGuard_1._assertGuard(_exceptionable, {
272
272
  method: "typia.createAssert",
273
273
  path: _path + ".ios",
274
274
  expected: "(string | undefined)",
@@ -280,7 +280,7 @@ export const assertAdPlacements = (() => {
280
280
  else if ("currency" === input.type)
281
281
  return _ao3(input, _path, true && _exceptionable);
282
282
  else
283
- return _a._assertGuard(_exceptionable, {
283
+ return _assertGuard_1._assertGuard(_exceptionable, {
284
284
  method: "typia.createAssert",
285
285
  path: _path,
286
286
  expected: _ae1,
@@ -306,12 +306,12 @@ export const assertAdPlacements = (() => {
306
306
  return (input, errorFactory) => {
307
307
  if (false === __is(input)) {
308
308
  _errorFactory = errorFactory;
309
- ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _a._assertGuard(true, {
309
+ ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _assertGuard_1._assertGuard(true, {
310
310
  method: "typia.createAssert",
311
311
  path: _path + "",
312
312
  expected: "AdPlacements",
313
313
  value: input
314
- }, _errorFactory)) && _ao0(input, _path + "", true) || _a._assertGuard(true, {
314
+ }, _errorFactory)) && _ao0(input, _path + "", true) || _assertGuard_1._assertGuard(true, {
315
315
  method: "typia.createAssert",
316
316
  path: _path + "",
317
317
  expected: "AdPlacements",
@@ -323,28 +323,28 @@ export const assertAdPlacements = (() => {
323
323
  })();
324
324
  export const assertProductGrant = (() => {
325
325
  const _ae0 = "({ readonly type: \"currency\"; readonly currency: \"coin\" | \"gem\"; readonly amount: number; } | { readonly type: \"entitlement\"; readonly entitlement: string; })";
326
- const _ao0 = (input, _path, _exceptionable = true) => ("currency" === input.type || _a._assertGuard(_exceptionable, {
326
+ const _ao0 = (input, _path, _exceptionable = true) => ("currency" === input.type || _assertGuard_1._assertGuard(_exceptionable, {
327
327
  method: "typia.createAssert",
328
328
  path: _path + ".type",
329
329
  expected: "\"currency\"",
330
330
  value: input.type
331
- }, _errorFactory)) && ("coin" === input.currency || "gem" === input.currency || _a._assertGuard(_exceptionable, {
331
+ }, _errorFactory)) && ("coin" === input.currency || "gem" === input.currency || _assertGuard_1._assertGuard(_exceptionable, {
332
332
  method: "typia.createAssert",
333
333
  path: _path + ".currency",
334
334
  expected: "(\"coin\" | \"gem\")",
335
335
  value: input.currency
336
- }, _errorFactory)) && ("number" === typeof input.amount || _a._assertGuard(_exceptionable, {
336
+ }, _errorFactory)) && ("number" === typeof input.amount || _assertGuard_1._assertGuard(_exceptionable, {
337
337
  method: "typia.createAssert",
338
338
  path: _path + ".amount",
339
339
  expected: "number",
340
340
  value: input.amount
341
341
  }, _errorFactory));
342
- const _ao1 = (input, _path, _exceptionable = true) => ("entitlement" === input.type || _a._assertGuard(_exceptionable, {
342
+ const _ao1 = (input, _path, _exceptionable = true) => ("entitlement" === input.type || _assertGuard_1._assertGuard(_exceptionable, {
343
343
  method: "typia.createAssert",
344
344
  path: _path + ".type",
345
345
  expected: "\"entitlement\"",
346
346
  value: input.type
347
- }, _errorFactory)) && ("string" === typeof input.entitlement || _a._assertGuard(_exceptionable, {
347
+ }, _errorFactory)) && ("string" === typeof input.entitlement || _assertGuard_1._assertGuard(_exceptionable, {
348
348
  method: "typia.createAssert",
349
349
  path: _path + ".entitlement",
350
350
  expected: "string",
@@ -356,7 +356,7 @@ export const assertProductGrant = (() => {
356
356
  else if ("entitlement" === input.type)
357
357
  return _ao1(input, _path, true && _exceptionable);
358
358
  else
359
- return _a._assertGuard(_exceptionable, {
359
+ return _assertGuard_1._assertGuard(_exceptionable, {
360
360
  method: "typia.createAssert",
361
361
  path: _path,
362
362
  expected: _ae0,
@@ -378,12 +378,12 @@ export const assertProductGrant = (() => {
378
378
  return (input, errorFactory) => {
379
379
  if (false === __is(input)) {
380
380
  _errorFactory = errorFactory;
381
- ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _a._assertGuard(true, {
381
+ ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _assertGuard_1._assertGuard(true, {
382
382
  method: "typia.createAssert",
383
383
  path: _path + "",
384
384
  expected: _ae0,
385
385
  value: input
386
- }, _errorFactory)) && _au0(input, _path + "", true) || _a._assertGuard(true, {
386
+ }, _errorFactory)) && _au0(input, _path + "", true) || _assertGuard_1._assertGuard(true, {
387
387
  method: "typia.createAssert",
388
388
  path: _path + "",
389
389
  expected: _ae0,
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@mpgd/catalog",
3
- "version": "0.3.4",
3
+ "version": "0.3.5",
4
4
  "description": "Product catalog and ad placement configuration schemas for mpgd games.",
5
5
  "license": "MIT",
6
6
  "repository": {
@@ -38,12 +38,12 @@
38
38
  "placements.json"
39
39
  ],
40
40
  "dependencies": {
41
- "typia": "rc",
42
- "@mpgd/platform": "0.5.0"
41
+ "typia": "13.0.2",
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",