hella-types 0.0.6 → 0.0.8

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 (5) hide show
  1. package/.gitattributes +2 -0
  2. package/dist/index.d.ts +56071 -4621
  3. package/dist/index.js +884 -888
  4. package/package.json +5 -2
  5. package/src/index.ts +944 -945
package/src/index.ts CHANGED
@@ -1,1051 +1,1050 @@
1
- import * as t from 'io-ts';
1
+ import * as z from 'zod';
2
2
 
3
- export const AttributesKeyFrameIO = t.type({
4
- level: t.number,
5
- data: t.type({
6
- maxHp: t.number,
7
- atk: t.number,
8
- def: t.number,
9
- magicResistance: t.number,
10
- cost: t.number,
11
- blockCnt: t.number,
12
- moveSpeed: t.number,
13
- attackSpeed: t.number,
14
- baseAttackTime: t.number,
15
- respawnTime: t.number,
16
- hpRecoveryPerSec: t.number,
17
- spRecoveryPerSec: t.number,
18
- maxDeployCount: t.number,
19
- maxDeckStackCnt: t.number,
20
- tauntLevel: t.number,
21
- massLevel: t.number,
22
- baseForceLevel: t.number,
23
- stunImmune: t.boolean,
24
- silenceImmune: t.boolean,
25
- sleepImmune: t.boolean,
26
- frozenImmune: t.boolean,
27
- levitateImmune: t.boolean,
28
- }),
3
+ const DefinedStringZod = z.strictObject({
4
+ m_defined: z.boolean(),
5
+ m_value: z.union([z.string(), z.null()]),
29
6
  });
30
- export const BlackboardIO = t.type({
31
- key: t.string,
32
- value: t.union([t.number, t.undefined]),
33
- valueStr: t.union([t.string, t.undefined]),
7
+ const DefinedStringArrayZod = z.strictObject({
8
+ m_defined: z.boolean(),
9
+ m_value: z.union([z.array(z.string()), z.null()]),
34
10
  });
35
- export const EnemyAttributesIO = t.type({
36
- maxHp: t.type({
37
- m_defined: t.boolean,
38
- m_value: t.number,
39
- }),
40
- atk: t.type({
41
- m_defined: t.boolean,
42
- m_value: t.number,
43
- }),
44
- def: t.type({
45
- m_defined: t.boolean,
46
- m_value: t.number,
47
- }),
48
- magicResistance: t.type({
49
- m_defined: t.boolean,
50
- m_value: t.number,
51
- }),
52
- cost: t.type({
53
- m_defined: t.boolean,
54
- m_value: t.number,
55
- }),
56
- blockCnt: t.type({
57
- m_defined: t.boolean,
58
- m_value: t.number,
59
- }),
60
- moveSpeed: t.type({
61
- m_defined: t.boolean,
62
- m_value: t.number,
63
- }),
64
- attackSpeed: t.type({
65
- m_defined: t.boolean,
66
- m_value: t.number,
67
- }),
68
- baseAttackTime: t.type({
69
- m_defined: t.boolean,
70
- m_value: t.number,
71
- }),
72
- respawnTime: t.type({
73
- m_defined: t.boolean,
74
- m_value: t.number,
75
- }),
76
- hpRecoveryPerSec: t.type({
77
- m_defined: t.boolean,
78
- m_value: t.number,
79
- }),
80
- spRecoveryPerSec: t.type({
81
- m_defined: t.boolean,
82
- m_value: t.number,
83
- }),
84
- maxDeployCount: t.type({
85
- m_defined: t.boolean,
86
- m_value: t.number,
87
- }),
88
- massLevel: t.type({
89
- m_defined: t.boolean,
90
- m_value: t.number,
91
- }),
92
- baseForceLevel: t.type({
93
- m_defined: t.boolean,
94
- m_value: t.number,
95
- }),
96
- tauntLevel: t.type({
97
- m_defined: t.boolean,
98
- m_value: t.number,
99
- }),
100
- stunImmune: t.type({
101
- m_defined: t.boolean,
102
- m_value: t.boolean,
103
- }),
104
- silenceImmune: t.type({
105
- m_defined: t.boolean,
106
- m_value: t.boolean,
107
- }),
108
- sleepImmune: t.type({
109
- m_defined: t.boolean,
110
- m_value: t.boolean,
111
- }),
112
- frozenImmune: t.type({
113
- m_defined: t.boolean,
114
- m_value: t.boolean,
115
- }),
116
- levitateImmune: t.type({
117
- m_defined: t.boolean,
118
- m_value: t.boolean,
11
+ const DefinedNumberZod = z.strictObject({
12
+ m_defined: z.boolean(),
13
+ m_value: z.union([z.number(), z.null()]),
14
+ });
15
+ const DefinedBooleanZod = z.strictObject({
16
+ m_defined: z.boolean(),
17
+ m_value: z.boolean(),
18
+ });
19
+
20
+ const AttributesKeyFrameZod = z.strictObject({
21
+ level: z.number(),
22
+ data: z.strictObject({
23
+ maxHp: z.number(),
24
+ atk: z.number(),
25
+ def: z.number(),
26
+ magicResistance: z.number(),
27
+ cost: z.number(),
28
+ blockCnt: z.number(),
29
+ moveSpeed: z.number(),
30
+ attackSpeed: z.number(),
31
+ baseAttackTime: z.number(),
32
+ respawnTime: z.number(),
33
+ hpRecoveryPerSec: z.number(),
34
+ spRecoveryPerSec: z.number(),
35
+ maxDeployCount: z.number(),
36
+ maxDeckStackCnt: z.number(),
37
+ tauntLevel: z.number(),
38
+ massLevel: z.number(),
39
+ baseForceLevel: z.number(),
40
+ stunImmune: z.boolean(),
41
+ silenceImmune: z.boolean(),
42
+ sleepImmune: z.boolean(),
43
+ frozenImmune: z.boolean(),
44
+ levitateImmune: z.boolean(),
119
45
  }),
120
46
  });
121
- export const EnemySkillsIO = t.type({
122
- prefabKey: t.string,
123
- priority: t.number,
124
- cooldown: t.number,
125
- initCooldown: t.number,
126
- spCost: t.number,
127
- blackboard: t.array(BlackboardIO),
47
+ const BlackboardZod = z.strictObject({
48
+ key: z.string(),
49
+ value: z.union([z.number(), z.null()]),
50
+ valueStr: z.union([z.string(), z.null(), z.undefined()]),
128
51
  });
129
- export const EnemySpDataIO = t.type({
130
- spType: t.number,
131
- maxSp: t.number,
132
- initSp: t.number,
133
- increment: t.number,
52
+ const EnemyAttributesZod = z.strictObject({
53
+ maxHp: DefinedNumberZod,
54
+ atk: DefinedNumberZod,
55
+ def: DefinedNumberZod,
56
+ magicResistance: DefinedNumberZod,
57
+ cost: DefinedNumberZod,
58
+ blockCnt: DefinedNumberZod,
59
+ moveSpeed: DefinedNumberZod,
60
+ attackSpeed: DefinedNumberZod,
61
+ baseAttackTime: DefinedNumberZod,
62
+ respawnTime: DefinedNumberZod,
63
+ hpRecoveryPerSec: DefinedNumberZod,
64
+ spRecoveryPerSec: DefinedNumberZod,
65
+ maxDeployCount: DefinedNumberZod,
66
+ massLevel: DefinedNumberZod,
67
+ baseForceLevel: DefinedNumberZod,
68
+ tauntLevel: z.union([DefinedNumberZod, z.undefined()]), // legacy
69
+ epDamageResistance: z.union([DefinedNumberZod, z.undefined()]), // legacy
70
+ epResistance: z.union([DefinedNumberZod, z.undefined()]), // ~
71
+ stunImmune: DefinedBooleanZod,
72
+ silenceImmune: DefinedBooleanZod,
73
+ sleepImmune: z.union([DefinedBooleanZod, z.undefined()]),
74
+ frozenImmune: z.union([DefinedBooleanZod, z.undefined()]), // legacy
75
+ levitateImmune: z.union([DefinedBooleanZod, z.undefined()]), // legacy
134
76
  });
135
- export const GridRangeIO = t.type({
136
- id: t.string,
137
- direction: t.number,
138
- grids: t.array(
139
- t.type({
140
- row: t.number,
141
- col: t.number,
142
- })
143
- ),
77
+ const EnemySkillsZod = z.strictObject({
78
+ prefabKey: z.string(),
79
+ priority: z.number(),
80
+ cooldown: z.number(),
81
+ initCooldown: z.number(),
82
+ spCost: z.number(),
83
+ blackboard: z.union([z.array(BlackboardZod), z.null()]),
84
+ });
85
+ const EnemySpDataZod = z.strictObject({
86
+ spType: z.string(),
87
+ maxSp: z.number(),
88
+ initSp: z.number(),
89
+ increment: z.number(),
90
+ });
91
+ const EnemyDataZod = z.strictObject({
92
+ name: DefinedStringZod,
93
+ description: DefinedStringZod,
94
+ prefabKey: DefinedStringZod,
95
+ attributes: EnemyAttributesZod,
96
+ applyWay: z.union([DefinedStringZod, z.undefined()]), // legacy
97
+ motion: z.union([DefinedStringZod, z.undefined()]), // legacy
98
+ enemyTags: z.union([DefinedStringArrayZod, z.undefined()]), // legacy
99
+ lifePointReduce: DefinedNumberZod,
100
+ levelType: z.union([DefinedStringZod, DefinedNumberZod, z.undefined()]), // legacy
101
+ rangeRadius: DefinedNumberZod,
102
+ numOfExtraDrops: z.union([DefinedNumberZod, z.undefined()]), // legacy
103
+ viewRadius: z.union([DefinedNumberZod, z.undefined()]), // legacy
104
+ notCountInTotal: z.union([DefinedBooleanZod, z.undefined()]), // legacy
105
+ talentBlackboard: z.union([z.array(BlackboardZod), z.null()]),
106
+ skills: z.union([z.array(EnemySkillsZod), z.null()]),
107
+ spData: z.union([EnemySpDataZod, z.null()]),
144
108
  });
145
- export const LevelUpCostIO = t.type({
146
- id: t.string,
147
- count: t.number,
148
- type: t.string,
109
+ const LevelUpCostZod = z.strictObject({
110
+ id: z.string(),
111
+ count: z.number(),
112
+ type: z.string(),
149
113
  });
150
- export const ManufactFormulaIO = t.type({
151
- formulaId: t.string,
152
- itemId: t.string,
153
- count: t.number,
154
- weight: t.number,
155
- costPoint: t.number,
156
- formulaType: t.string,
157
- buffType: t.string,
158
- costs: t.array(LevelUpCostIO),
159
- requireRooms: t.array(
160
- t.type({
161
- roomId: t.string,
162
- roomLevel: t.number,
163
- roomCount: t.number,
114
+ const ManufactFormulaZod = z.strictObject({
115
+ formulaId: z.string(),
116
+ itemId: z.string(),
117
+ count: z.number(),
118
+ weight: z.number(),
119
+ costPoint: z.number(),
120
+ formulaType: z.string(),
121
+ buffType: z.string(),
122
+ costs: z.array(LevelUpCostZod),
123
+ requireRooms: z.array(
124
+ z.strictObject({
125
+ roomId: z.string(),
126
+ roomLevel: z.number(),
127
+ roomCount: z.number(),
164
128
  })
165
129
  ),
166
- requireStages: t.array(
167
- t.type({
168
- stageId: t.string,
169
- rank: t.number,
130
+ requireStages: z.array(
131
+ z.strictObject({
132
+ stageId: z.string(),
133
+ rank: z.number(),
170
134
  })
171
135
  ),
172
136
  });
173
- export const WorkshopFormulaIO = t.type({
174
- sortId: t.number,
175
- formulaId: t.string,
176
- rarity: t.number,
177
- itemId: t.string,
178
- count: t.number,
179
- goldCost: t.number,
180
- apCost: t.number,
181
- formulaType: t.string,
182
- buffType: t.string,
183
- extraOutcomeRate: t.number,
184
- extraOutcomeGroup: t.array(
185
- t.type({
186
- weight: t.number,
187
- itemId: t.string,
188
- itemCount: t.number,
137
+ const WorkshopFormulaZod = z.strictObject({
138
+ sortId: z.number(),
139
+ formulaId: z.string(),
140
+ rarity: z.number(),
141
+ itemId: z.string(),
142
+ count: z.number(),
143
+ goldCost: z.number(),
144
+ apCost: z.number(),
145
+ formulaType: z.string(),
146
+ buffType: z.string(),
147
+ extraOutcomeRate: z.number(),
148
+ extraOutcomeGroup: z.array(
149
+ z.strictObject({
150
+ weight: z.number(),
151
+ itemId: z.string(),
152
+ itemCount: z.number(),
189
153
  })
190
154
  ),
191
- costs: t.array(LevelUpCostIO),
192
- requireRooms: t.array(
193
- t.type({
194
- roomId: t.string,
195
- roomLevel: t.number,
196
- roomCount: t.number,
155
+ costs: z.array(LevelUpCostZod),
156
+ requireRooms: z.array(
157
+ z.strictObject({
158
+ roomId: z.string(),
159
+ roomLevel: z.number(),
160
+ roomCount: z.number(),
197
161
  })
198
162
  ),
199
- requireStages: t.array(
200
- t.type({
201
- stageId: t.string,
202
- rank: t.number,
163
+ requireStages: z.array(
164
+ z.strictObject({
165
+ stageId: z.string(),
166
+ rank: z.number(),
203
167
  })
204
168
  ),
205
169
  });
206
- export const OperatorUnlockCondIO = t.type({
207
- phase: t.string,
208
- level: t.number,
170
+ const OperatorUnlockCondZod = z.strictObject({
171
+ phase: z.union([z.string(), z.number()]),
172
+ level: z.number(),
209
173
  });
210
- export const LevelUpCostCondIO = t.type({
211
- unlockCond: OperatorUnlockCondIO,
212
- lvlUpTime: t.number,
213
- levelUpCost: t.array(LevelUpCostIO),
174
+ const LevelUpCostCondZod = z.strictObject({
175
+ unlockCond: OperatorUnlockCondZod,
176
+ lvlUpTime: z.number(),
177
+ levelUpCost: z.union([z.array(LevelUpCostZod), z.null()]),
214
178
  });
215
- export const StageDefinesIO = t.type({
216
- characterInsts: t.array(t.any),
217
- tokenInsts: t.array(
218
- t.type({
219
- position: t.type({
220
- row: t.number,
221
- col: t.number,
179
+ const StageDefinesZod = z.strictObject({
180
+ characterInsts: z.array(z.any()),
181
+ tokenInsts: z.array(
182
+ z.strictObject({
183
+ position: z.strictObject({
184
+ row: z.number(),
185
+ col: z.number(),
222
186
  }),
223
- direction: t.number,
224
- hidden: t.boolean,
225
- alias: t.string,
226
- uniEquipIds: t.array(
227
- t.type({
228
- key: t.string,
229
- level: t.number,
230
- })
187
+ direction: z.union([z.string(), z.number()]), // legacy
188
+ hidden: z.boolean(),
189
+ alias: z.union([z.string(), z.null()]),
190
+ uniEquipIds: z.union([
191
+ z.array(
192
+ z.strictObject({
193
+ key: z.string(),
194
+ level: z.number(),
195
+ })
196
+ ),
197
+ z.null(), z.undefined()] // legacy
231
198
  ),
232
- inst: t.type({
233
- characterKey: t.string,
234
- level: t.number,
235
- phase: t.number,
236
- favorPoint: t.number,
237
- potentialRank: t.number,
199
+ inst: z.strictObject({
200
+ characterKey: z.string(),
201
+ level: z.number(),
202
+ phase: z.union([z.string(), z.number()]), // legacy
203
+ favorPoint: z.number(),
204
+ potentialRank: z.number(),
238
205
  }),
239
- skillIndex: t.number,
240
- mainSkillLvl: t.number,
241
- skinId: t.string,
242
- tmplId: t.string,
243
- overrideSkillBlackboard: t.array(BlackboardIO),
206
+ skillIndex: z.number(),
207
+ mainSkillLvl: z.number(),
208
+ skinId: z.union([z.string(), z.null()]),
209
+ tmplId: z.union([z.string(), z.null(), z.undefined()]),
210
+ overrideSkillBlackboard: z.union([z.array(BlackboardZod), z.null(), z.undefined()]),
244
211
  })
245
212
  ),
246
- characterCards: t.array(t.any),
247
- tokenCards: t.array(t.any),
213
+ characterCards: z.array(z.any()),
214
+ tokenCards: z.array(z.any()),
248
215
  });
249
- export const StageEffectIO = t.type({
250
- key: t.string,
251
- offset: t.type({
252
- x: t.number,
253
- y: t.number,
254
- z: t.number,
216
+ const StageEffectZod = z.strictObject({
217
+ key: z.string(),
218
+ offset: z.strictObject({
219
+ x: z.number(),
220
+ y: z.number(),
221
+ z: z.number(),
255
222
  }),
256
- direction: t.number,
223
+ direction: z.union([z.string(), z.number()]), // legacy
224
+ });
225
+ const StageActionZod = z.strictObject({
226
+ actionType: z.union([z.string(), z.number()]), // legacy
227
+ managedByScheduler: z.boolean(),
228
+ key: z.string(),
229
+ count: z.number(),
230
+ preDelay: z.number(),
231
+ interval: z.number(),
232
+ routeIndex: z.number(),
233
+ blockFragment: z.boolean(),
234
+ autoPreviewRoute: z.boolean(),
235
+ autoDisplayEnemyInfo: z.union([z.boolean(), z.undefined()]), // legacy
236
+ isUnharmfulAndAlwaysCountAsKilled: z.boolean(),
237
+ hiddenGroup: z.union([z.string(), z.null()]),
238
+ randomSpawnGroupKey: z.union([z.string(), z.null(), z.undefined()]), // legacy
239
+ randomSpawnGroupPackKey: z.union([z.string(), z.null(), z.undefined()]), // ~
240
+ randomType: z.union([z.string(), z.number(), z.undefined()]), // ~
241
+ weight: z.union([z.number(), z.undefined()]), // ~
242
+ dontBlockWave: z.union([z.boolean(), z.undefined()]), // ~
243
+ isValid: z.union([z.boolean(), z.undefined()]), // ~
244
+ extraMeta: z.union([z.null(), z.undefined()]), // ~
257
245
  });
258
- export const StageDataIO = t.type({
259
- options: t.type({
260
- characterLimit: t.number,
261
- maxLifePoint: t.number,
262
- initialCost: t.number,
263
- maxCost: t.number,
264
- costIncreaseTime: t.number,
265
- moveMultiplier: t.number,
266
- steeringEnabled: t.boolean,
267
- isTrainingLevel: t.boolean,
268
- isHardTrainingLevel: t.boolean,
269
- functionDisableMask: t.number,
246
+ const StageDataZod = z.strictObject({
247
+ options: z.strictObject({
248
+ characterLimit: z.number(),
249
+ maxLifePoint: z.number(),
250
+ initialCost: z.number(),
251
+ maxCost: z.number(),
252
+ costIncreaseTime: z.number(),
253
+ moveMultiplier: z.number(),
254
+ steeringEnabled: z.boolean(),
255
+ isTrainingLevel: z.boolean(),
256
+ isHardTrainingLevel: z.union([z.boolean(), z.undefined()]), // legacy
257
+ isPredefinedCardsSelectable: z.union([z.boolean(), z.undefined()]), // legacy
258
+ maxPlayTime: z.union([z.number(), z.undefined()]), // legacy
259
+ functionDisableMask: z.union([z.string(), z.number()]),
260
+ configBlackBoard: z.union([z.array(BlackboardZod), z.null(), z.undefined()]), // legacy
270
261
  }),
271
- levelId: t.string,
272
- mapId: t.string,
273
- bgmEvent: t.string,
274
- environmentSe: t.string,
275
- mapData: t.type({
276
- map: t.array(t.array(t.number)),
277
- tiles: t.array(
278
- t.type({
279
- tileKey: t.string,
280
- heightType: t.number,
281
- buildableType: t.number,
282
- passableMask: t.number,
283
- playerSideMask: t.number,
284
- blackboard: BlackboardIO,
285
- effects: t.array(StageEffectIO),
262
+ levelId: z.union([z.string(), z.null()]),
263
+ mapId: z.union([z.string(), z.null()]),
264
+ bgmEvent: z.union([z.string(), z.null()]),
265
+ environmentSe: z.union([z.string(), z.null()]),
266
+ mapData: z.strictObject({
267
+ map: z.array(z.array(z.number())),
268
+ tiles: z.array(
269
+ z.strictObject({
270
+ tileKey: z.string(),
271
+ heightType: z.union([z.string(), z.number()]), // keep number for legacy stages (monster hunter, vignettes, etc.)
272
+ buildableType: z.union([z.string(), z.number()]), // ~
273
+ passableMask: z.union([z.string(), z.number()]), // ~
274
+ playerSideMask: z.union([z.string(), z.number(), z.undefined()]), // ~
275
+ blackboard: z.union([z.array(BlackboardZod), z.null()]),
276
+ effects: z.union([z.array(StageEffectZod), z.null()]),
286
277
  })
287
278
  ),
288
- blockEdges: t.null,
289
- tags: t.array(t.string),
290
- effects: t.array(StageEffectIO),
291
- layerRects: t.array(t.string),
292
- width: t.number,
293
- height: t.number,
279
+ blockEdges: z.union([z.array(z.any()), z.null()]),
280
+ tags: z.union([z.array(z.string()), z.null()]),
281
+ effects: z.union([z.array(StageEffectZod), z.null()]),
282
+ layerRects: z.union([z.null(), z.undefined()]),
283
+ width: z.number().optional(),
284
+ height: z.number().optional(),
294
285
  }),
295
- tilesDisallowToLocate: t.array(t.any),
296
- runes: t.array(
297
- t.type({
298
- difficultyMask: t.number,
299
- key: t.string,
300
- professionMask: t.number,
301
- buildableMask: t.number,
302
- blackboard: t.array(BlackboardIO),
303
- })
304
- ),
305
- globalBuffs: t.array(
306
- t.type({
307
- prefabKey: t.string,
308
- blackboard: t.array(BlackboardIO),
309
- overrideCameraEffect: t.null,
310
- passProfessionMaskFlag: t.boolean,
311
- professionMask: t.number,
312
- })
313
- ),
314
- routes: t.array(
315
- t.type({
316
- motionMode: t.number,
317
- startPosition: t.type({
318
- row: t.number,
319
- col: t.number,
320
- }),
321
- endPosition: t.type({
322
- row: t.number,
323
- col: t.number,
324
- }),
325
- spawnRandomRange: t.type({
326
- x: t.number,
327
- y: t.number,
328
- }),
329
- spawnOffset: t.type({
330
- x: t.number,
331
- y: t.number,
332
- }),
333
- checkpoints: t.array(
334
- t.type({
335
- type: t.number,
336
- time: t.number,
337
- position: t.type({
338
- row: t.number,
339
- col: t.number,
340
- }),
341
- reachOffset: t.type({
342
- x: t.number,
343
- y: t.number,
344
- }),
345
- randomizeReachOffset: t.boolean,
346
- reachDistance: t.number,
347
- })
348
- ),
349
- allowDiagonalMove: t.boolean,
350
- visitEveryTileCenter: t.boolean,
351
- visitEveryNodeCenter: t.boolean,
352
- visitEveryCheckPoint: t.boolean,
353
- })
354
- ),
355
- extraRoutes: t.array(t.any),
356
- enemies: t.array(t.any),
357
- enemyDbRefs: t.array(
358
- t.type({
359
- useDb: t.boolean,
360
- id: t.string,
361
- level: t.number,
362
- overwrittenData: t.type({
363
- name: t.type({
364
- m_defined: t.boolean,
365
- m_value: t.number,
366
- }),
367
- description: t.type({
368
- m_defined: t.boolean,
369
- m_value: t.number,
286
+ tilesDisallowToLocate: z.array(z.any()),
287
+ runes: z.union([
288
+ z.array(
289
+ z.strictObject({
290
+ difficultyMask: z.union([z.string(), z.number()]), // legacy
291
+ key: z.string(),
292
+ professionMask: z.union([z.string(), z.number(), z.undefined()]), // legacy
293
+ buildableMask: z.union([z.string(), z.number()]), // legacy
294
+ blackboard: z.array(BlackboardZod),
295
+ })
296
+ ),
297
+ z.null()
298
+ ]),
299
+ globalBuffs: z.union([
300
+ z.array(
301
+ z.strictObject({
302
+ prefabKey: z.string(),
303
+ blackboard: z.union([z.array(BlackboardZod), z.null()]),
304
+ overrideCameraEffect: z.null(),
305
+ passProfessionMaskFlag: z.union([z.boolean(), z.undefined()]),
306
+ professionMask: z.union([z.string(), z.number(), z.undefined()]),
307
+ useExtraData: z.boolean().optional(),
308
+ })
309
+ ),
310
+ z.null()
311
+ ]),
312
+ routes: z.array(
313
+ z.union([
314
+ z.strictObject({
315
+ motionMode: z.union([z.string(), z.number()]), // keep number for legacy
316
+ startPosition: z.strictObject({
317
+ row: z.number(),
318
+ col: z.number(),
370
319
  }),
371
- prefabKey: t.type({
372
- m_defined: t.boolean,
373
- m_value: t.number,
320
+ endPosition: z.strictObject({
321
+ row: z.number(),
322
+ col: z.number(),
374
323
  }),
375
- attributes: EnemyAttributesIO,
376
- lifePointReduce: t.type({
377
- m_defined: t.boolean,
378
- m_value: t.number,
324
+ spawnRandomRange: z.strictObject({
325
+ x: z.number(),
326
+ y: z.number(),
379
327
  }),
380
- rangeRadius: t.type({
381
- m_defined: t.boolean,
382
- m_value: t.number,
328
+ spawnOffset: z.strictObject({
329
+ x: z.number(),
330
+ y: z.number(),
383
331
  }),
384
- talentBlackboard: t.array(BlackboardIO),
385
- skills: t.array(EnemySkillsIO),
386
- spData: EnemySpDataIO,
332
+ checkpoints: z.union([
333
+ z.array(
334
+ z.strictObject({
335
+ type: z.union([z.string(), z.number()]), // keep number for legacy
336
+ time: z.number(),
337
+ position: z.strictObject({
338
+ row: z.number(),
339
+ col: z.number(),
340
+ }),
341
+ reachOffset: z.strictObject({
342
+ x: z.number(),
343
+ y: z.number(),
344
+ }),
345
+ randomizeReachOffset: z.boolean(),
346
+ reachDistance: z.number(),
347
+ })
348
+ ),
349
+ z.null()
350
+ ]),
351
+ allowDiagonalMove: z.boolean(),
352
+ visitEveryTileCenter: z.boolean(),
353
+ visitEveryNodeCenter: z.boolean(),
354
+ visitEveryCheckPoint: z.union([z.boolean(), z.undefined()]), // legacy
387
355
  }),
356
+ z.null() // legacy
357
+ ])
358
+ ),
359
+ extraRoutes: z.union([z.array(z.any()), z.undefined()]),
360
+ enemies: z.array(z.any()),
361
+ enemyDbRefs: z.array(
362
+ z.strictObject({
363
+ useDb: z.boolean(),
364
+ id: z.string(),
365
+ level: z.number(),
366
+ overwrittenData: z.union([EnemyDataZod, z.null()]),
388
367
  })
389
368
  ),
390
- waves: t.array(
391
- t.type({
392
- preDelay: t.number,
393
- postDelay: t.number,
394
- maxTimeWaitingForNextWave: t.number,
395
- fragments: t.array(
396
- t.type({
397
- preDelay: t.number,
398
- actions: t.array(
399
- t.type({
400
- actionType: t.number,
401
- managedByScheduler: t.boolean,
402
- key: t.string,
403
- count: t.number,
404
- preDelay: t.number,
405
- interval: t.number,
406
- routeIndex: t.number,
407
- blockFragment: t.boolean,
408
- autoPreviewRoute: t.boolean,
409
- isUnharmfulAndAlwaysCountAsKilled: t.boolean,
410
- hiddenGroup: t.string,
411
- randomSpawnGroupKey: t.string,
412
- weight: t.number,
413
- dontBlockWave: t.boolean,
414
- })
415
- ),
416
- name: t.string,
417
- })
418
- ),
369
+ waves: z.array(
370
+ z.strictObject({
371
+ preDelay: z.number(),
372
+ postDelay: z.number(),
373
+ maxTimeWaitingForNextWave: z.number(),
374
+ fragments: z.array(z.strictObject({
375
+ preDelay: z.number(),
376
+ actions: z.array(StageActionZod),
377
+ name: z.string().nullable().optional(),
378
+ })),
379
+ advancedWaveTag: z.union([z.string(), z.null(), z.undefined()]), // legacy
380
+ name: z.string().nullable().optional(),
419
381
  })
420
382
  ),
421
- branches: t.type({
422
- frosts: t.type({
423
- phases: t.array(
424
- t.type({
425
- preDelay: t.number,
426
- actions: t.array(
427
- t.type({
428
- actionType: t.number,
429
- managedByScheduler: t.boolean,
430
- key: t.string,
431
- count: t.number,
432
- preDelay: t.number,
433
- interval: t.number,
434
- routeIndex: t.number,
435
- blockFragment: t.boolean,
436
- autoPreviewRoute: t.boolean,
437
- isUnharmfulAndAlwaysCountAsKilled: t.boolean,
438
- hiddenGroup: t.string,
439
- randomSpawnGroupKey: t.string,
440
- weight: t.number,
441
- weightValue: t.number,
442
- })
443
- ),
444
- })
445
- ),
446
- }),
447
- }),
448
- predefines: StageDefinesIO,
449
- hardPredefines: StageDefinesIO,
450
- excludeCharIdList: t.null,
451
- randomSeed: t.number,
452
- operaConfig: t.string,
383
+ branches: z.union([
384
+ z.record(
385
+ z.string(),
386
+ z.strictObject({
387
+ phases: z.array(z.strictObject({
388
+ preDelay: z.number(),
389
+ actions: z.array(StageActionZod),
390
+ m_randomActionGroups: z.null().optional(),
391
+ m_actionWithRandomSpawn: z.null().optional(),
392
+ m_validActionPackKeys: z.null().optional(),
393
+ })),
394
+ }),
395
+ ),
396
+ z.null()
397
+ ]),
398
+ predefines: z.union([StageDefinesZod, z.null()]),
399
+ hardPredefines: z.union([StageDefinesZod, z.null(), z.undefined()]),
400
+ excludeCharIdList: z.null(),
401
+ randomSeed: z.number(),
402
+ operaConfig: z.union([z.string(), z.null(), z.undefined()]),
403
+ runtimeData: z.union([z.null(), z.undefined()]), // legacy
453
404
  });
454
- export const RogueRelicIO = t.type({
455
- id: t.string,
456
- name: t.string,
457
- description: t.string,
458
- usage: t.string,
459
- obtainApproach: t.string,
460
- iconId: t.string,
461
- type: t.string,
462
- subType: t.string,
463
- rarity: t.string,
464
- value: t.number,
465
- sortId: t.number,
466
- canSacrifice: t.boolean,
467
- unlockCondDesc: t.string,
405
+ const RogueRelicZod = z.strictObject({
406
+ id: z.string(),
407
+ name: z.string(),
408
+ description: z.union([z.string(), z.null()]),
409
+ usage: z.string(),
410
+ obtainApproach: z.string(),
411
+ iconId: z.string(),
412
+ type: z.string(),
413
+ subType: z.string(),
414
+ rarity: z.string(),
415
+ value: z.number(),
416
+ sortId: z.number(),
417
+ canSacrifice: z.boolean(),
418
+ unlockCondDesc: z.union([z.string(), z.null()]),
468
419
  });
469
- export const RogueStageIO = t.type({
470
- excel: t.type({
471
- id: t.string,
472
- linkedStageId: t.string,
473
- levelId: t.string,
474
- code: t.string,
475
- name: t.string,
476
- loadingPicId: t.string,
477
- description: t.string,
478
- eliteDesc: t.string,
479
- isBoss: t.number,
480
- isElite: t.number,
481
- difficulty: t.string,
482
- capsulePool: t.string,
483
- capsuleProb: t.number,
484
- vutresProb: t.array(t.number),
485
- boxProb: t.array(t.number),
420
+ const RogueStageZod = z.strictObject({
421
+ excel: z.strictObject({
422
+ id: z.string(),
423
+ linkedStageId: z.string(),
424
+ levelId: z.string(),
425
+ code: z.string(),
426
+ name: z.string(),
427
+ loadingPicId: z.string(),
428
+ description: z.string(),
429
+ eliteDesc: z.union([z.string(), z.null()]),
430
+ isBoss: z.number(),
431
+ isElite: z.number(),
432
+ difficulty: z.string(),
433
+ capsulePool: z.union([z.string(), z.null()]),
434
+ capsuleProb: z.number(),
435
+ vutresProb: z.array(z.number()),
436
+ boxProb: z.array(z.number()),
437
+ specialNodeId: z.string().nullable(),
486
438
  }),
487
- levels: StageDataIO,
439
+ levels: StageDataZod,
488
440
  });
489
- export const RogueVariationIO = t.type({
490
- id: t.string,
491
- type: t.string,
492
- outerName: t.string,
493
- innerName: t.string,
494
- functionDesc: t.string,
495
- desc: t.string,
496
- iconId: t.string,
497
- sound: t.string,
441
+ const RogueVariationZod = z.strictObject({
442
+ id: z.string(),
443
+ type: z.string(),
444
+ outerName: z.string(),
445
+ innerName: z.string(),
446
+ functionDesc: z.string(),
447
+ desc: z.string(),
448
+ iconId: z.union([z.string(), z.null()]),
449
+ sound: z.union([z.string(), z.null()]),
498
450
  });
499
- export const SandboxStageIO = t.type({
500
- excel: t.type({
501
- stageId: t.string,
502
- levelId: t.string,
503
- code: t.string,
504
- name: t.string,
505
- loadingPicId: t.string,
506
- description: t.string,
507
- actionCost: t.number,
508
- powerCost: t.number,
451
+ const SandboxStageZod = z.strictObject({
452
+ excel: z.strictObject({
453
+ stageId: z.string(),
454
+ levelId: z.string(),
455
+ code: z.string(),
456
+ name: z.string(),
457
+ loadingPicId: z.string(),
458
+ description: z.string(),
459
+ actionCost: z.number(),
460
+ powerCost: z.number(),
509
461
  }),
510
- levels: StageDataIO,
462
+ levels: StageDataZod,
511
463
  });
512
- export const BaseIO = t.type({
513
- buffId: t.string,
514
- buffName: t.string,
515
- buffIcon: t.string,
516
- skillIcon: t.string,
517
- sortId: t.number,
518
- buffColor: t.string,
519
- textColor: t.string,
520
- buffCategory: t.string,
521
- roomType: t.string,
522
- description: t.string,
464
+
465
+ export const BaseZod = z.strictObject({
466
+ buffId: z.string(),
467
+ buffName: z.string(),
468
+ buffIcon: z.string(),
469
+ skillIcon: z.string(),
470
+ sortId: z.number(),
471
+ buffColor: z.string(),
472
+ textColor: z.string(),
473
+ buffCategory: z.string(),
474
+ roomType: z.string(),
475
+ description: z.string(),
523
476
  });
524
- export const CCStageIO = t.type({
525
- const: t.type({
526
- levelId: t.string,
527
- location: t.string,
528
- name: t.string,
529
- description: t.string,
477
+ export const CCStageZod = z.strictObject({
478
+ const: z.strictObject({
479
+ levelId: z.string(),
480
+ location: z.string(),
481
+ name: z.string(),
482
+ description: z.string(),
530
483
  }),
531
- levels: StageDataIO,
484
+ levels: StageDataZod,
532
485
  });
533
- export const DefinitionIO = t.type({
534
- termId: t.string,
535
- termName: t.string,
536
- description: t.string,
486
+ export const DefinitionZod = z.strictObject({
487
+ termId: z.string(),
488
+ termName: z.string(),
489
+ description: z.string(),
537
490
  });
538
- export const EnemyIO = t.type({
539
- excel: t.type({
540
- enemyId: t.string,
541
- enemyIndex: t.string,
542
- enemyTags: t.array(t.string),
543
- sortId: t.number,
544
- name: t.string,
545
- enemyRace: t.string,
546
- enemyLevel: t.string,
547
- description: t.string,
548
- attackType: t.string,
549
- endure: t.string,
550
- attack: t.string,
551
- defence: t.string,
552
- resistance: t.string,
553
- ability: t.string,
554
- isInvalidKilled: t.boolean,
555
- overrideKillCntInfos: t.record(t.string, t.any),
556
- hideInHandbook: t.boolean,
491
+ export const EnemyZod = z.strictObject({
492
+ excel: z.strictObject({
493
+ enemyId: z.string(),
494
+ enemyIndex: z.string(),
495
+ enemyTags: z.union([z.array(z.string()), z.null()]),
496
+ sortId: z.number(),
497
+ name: z.string(),
498
+ enemyLevel: z.enum(['NORMAL', 'ELITE', 'BOSS']),
499
+ description: z.string(),
500
+ attackType: z.null(),
501
+ ability: z.null(),
502
+ isInvalidKilled: z.boolean(),
503
+ overrideKillCntInfos: z.record(z.string(), z.any()),
504
+ hideInHandbook: z.boolean(),
505
+ abilityList: z.array(z.strictObject({
506
+ text: z.string(),
507
+ textFormat: z.enum(['NORMAL', 'SILENCE', 'TITLE'])
508
+ })),
509
+ linkEnemies: z.array(z.string()),
510
+ damageType: z.array(z.enum(['PHYSIC', 'MAGIC', 'NO_DAMAGE', 'HEAL'])),
511
+ invisibleDetail: z.boolean(),
557
512
  }),
558
- levels: t.type({
559
- Key: t.string,
560
- Value: t.array(
561
- t.type({
562
- level: t.number,
563
- enemyData: t.type({
564
- name: t.type({
565
- m_defined: t.boolean,
566
- m_value: t.string,
567
- }),
568
- description: t.type({
569
- m_defined: t.boolean,
570
- m_value: t.string,
571
- }),
572
- prefabKey: t.type({
573
- m_defined: t.boolean,
574
- m_value: t.string,
575
- }),
576
- attributes: EnemyAttributesIO,
577
- lifePointReduce: t.type({
578
- m_defined: t.boolean,
579
- m_value: t.number,
580
- }),
581
- levelType: t.type({
582
- m_defined: t.boolean,
583
- m_value: t.number,
584
- }),
585
- rangeRadius: t.type({
586
- m_defined: t.boolean,
587
- m_value: t.number,
588
- }),
589
- numOfExtraDrops: t.type({
590
- m_defined: t.boolean,
591
- m_value: t.number,
592
- }),
593
- talentBlackboard: t.array(BlackboardIO),
594
- skills: t.array(EnemySkillsIO),
595
- spData: EnemySpDataIO,
596
- }),
513
+ levels: z.strictObject({
514
+ Key: z.string(),
515
+ Value: z.array(
516
+ z.strictObject({
517
+ level: z.number(),
518
+ enemyData: EnemyDataZod,
597
519
  })
598
520
  ),
599
521
  }),
600
522
  });
601
- export const GameEventIO = t.type({
602
- id: t.string,
603
- type: t.string,
604
- displayType: t.string,
605
- name: t.string,
606
- startTime: t.number,
607
- endTime: t.number,
608
- rewardEndTime: t.number,
609
- displayOnHome: t.boolean,
610
- hasStage: t.boolean,
611
- templateShopId: t.string,
612
- medalGroupId: t.string,
613
- isReplicate: t.boolean,
523
+ export const GameEventZod = z.strictObject({
524
+ id: z.string(),
525
+ type: z.string(),
526
+ displayType: z.string(),
527
+ name: z.string(),
528
+ startTime: z.number(),
529
+ endTime: z.number(),
530
+ rewardEndTime: z.number(),
531
+ displayOnHome: z.boolean(),
532
+ hasStage: z.boolean(),
533
+ templateShopId: z.union([z.string(), z.null()]),
534
+ medalGroupId: z.union([z.string(), z.null()]),
535
+ ungroupedMedalIds: z.array(z.string()).nullable(),
536
+ isReplicate: z.boolean(),
537
+ needFixedSync: z.boolean(),
614
538
  });
615
- export const ItemIO = t.type({
616
- data: t.type({
617
- itemId: t.string,
618
- name: t.string,
619
- description: t.string,
620
- rarity: t.number,
621
- iconId: t.string,
622
- overrideBkg: t.null,
623
- stackIconId: t.string,
624
- sortId: t.number,
625
- usage: t.string,
626
- obtainApproach: t.string,
627
- classifyType: t.string,
628
- itemType: t.string,
629
- stageDropList: t.array(
630
- t.type({
631
- stageId: t.string,
632
- occPer: t.string,
539
+ export const GridRangeZod = z.strictObject({
540
+ id: z.string(),
541
+ direction: z.number(),
542
+ grids: z.array(
543
+ z.strictObject({
544
+ row: z.number(),
545
+ col: z.number(),
546
+ })
547
+ ),
548
+ });
549
+ export const ItemZod = z.strictObject({
550
+ data: z.strictObject({
551
+ itemId: z.string(),
552
+ name: z.string(),
553
+ description: z.union([z.string(), z.null()]),
554
+ rarity: z.string(),
555
+ iconId: z.string(),
556
+ overrideBkg: z.null(),
557
+ stackIconId: z.union([z.string(), z.null()]),
558
+ sortId: z.number(),
559
+ usage: z.union([z.string(), z.null()]),
560
+ obtainApproach: z.union([z.string(), z.null()]),
561
+ hideInItemGet: z.boolean(),
562
+ classifyType: z.string(),
563
+ itemType: z.string(),
564
+ stageDropList: z.array(
565
+ z.strictObject({
566
+ stageId: z.string(),
567
+ occPer: z.string(),
633
568
  })
634
569
  ),
635
- buildingProductList: t.array(
636
- t.type({
637
- roomType: t.string,
638
- formulaId: t.string,
570
+ buildingProductList: z.array(
571
+ z.strictObject({
572
+ roomType: z.string(),
573
+ formulaId: z.string(),
639
574
  })
640
575
  ),
641
576
  }),
642
- formula: t.union([ManufactFormulaIO, WorkshopFormulaIO]),
577
+ formula: z.union([ManufactFormulaZod, WorkshopFormulaZod, z.null()]),
643
578
  });
644
- export const ModuleIO = t.type({
645
- info: t.type({
646
- uniEquipId: t.string,
647
- uniEquipName: t.string,
648
- uniEquipIcon: t.string,
649
- uniEquipDesc: t.string,
650
- typeIcon: t.string,
651
- typeName1: t.string,
652
- typeName2: t.string,
653
- equipShiningColor: t.string,
654
- showEvolvePhase: t.number,
655
- unlockEvolvePhase: t.number,
656
- charId: t.string,
657
- tmplId: t.string,
658
- showLevel: t.number,
659
- unlockLevel: t.number,
660
- unlockFavorPoint: t.number,
661
- missionList: t.array(t.string),
662
- itemCost: t.record(t.string, t.array(LevelUpCostIO)),
663
- type: t.string,
664
- uniEquipGetTime: t.number,
665
- charEquipOrder: t.number,
666
- }),
667
- data: t.type({
668
- phases: t.array(
669
- t.type({
670
- equipLevel: t.number,
671
- parts: t.array(
672
- t.type({
673
- resKey: t.string,
674
- target: t.string,
675
- isToken: t.boolean,
676
- addOrOverrideTalentDataBundle: t.type({
677
- candidates: t.array(
678
- t.type({
679
- displayRangeId: t.boolean,
680
- upgradeDescription: t.string,
681
- talentIndex: t.number,
682
- unlockCondition: OperatorUnlockCondIO,
683
- requiredPotentialRank: t.number,
684
- prefabKey: t.string,
685
- name: t.string,
686
- description: t.string,
687
- rangeId: t.string,
688
- blackboard: t.array(BlackboardIO),
689
- })
690
- ),
691
- }),
692
- overrideTraitDataBundle: t.type({
693
- candidates: t.array(
694
- t.type({
695
- additionalDescription: t.string,
696
- unlockCondition: OperatorUnlockCondIO,
697
- requiredPotentialRank: t.number,
698
- blackboard: t.array(BlackboardIO),
699
- overrideDescripton: t.string,
700
- prefabKey: t.string,
701
- rangeId: t.string,
702
- })
703
- ),
704
- }),
705
- })
706
- ),
707
- attributeBlackboard: t.array(BlackboardIO),
708
- tokenAttributeBlackboard: t.record(t.string, t.array(BlackboardIO)),
709
- })
710
- ),
579
+ export const ModuleZod = z.strictObject({
580
+ info: z.strictObject({
581
+ uniEquipId: z.string(),
582
+ uniEquipName: z.string(),
583
+ uniEquipIcon: z.string(),
584
+ uniEquipDesc: z.string(),
585
+ typeIcon: z.string(),
586
+ typeName1: z.string(),
587
+ typeName2: z.union([z.string(), z.null()]),
588
+ equipShiningColor: z.string(),
589
+ showEvolvePhase: z.string(),
590
+ unlockEvolvePhase: z.string(),
591
+ charId: z.string(),
592
+ tmplId: z.union([z.string(), z.null()]),
593
+ showLevel: z.number(),
594
+ unlockLevel: z.number(),
595
+ unlockFavorPoint: z.number(),
596
+ missionList: z.array(z.string()),
597
+ itemCost: z.union([z.record(z.string(), z.array(LevelUpCostZod)), z.null()]),
598
+ type: z.string(),
599
+ uniEquipGetTime: z.number(),
600
+ charEquipOrder: z.number(),
711
601
  }),
602
+ data: z.union([
603
+ z.strictObject({
604
+ phases: z.array(
605
+ z.strictObject({
606
+ equipLevel: z.number(),
607
+ parts: z.array(
608
+ z.strictObject({
609
+ resKey: z.union([z.string(), z.null()]),
610
+ target: z.string(),
611
+ isToken: z.boolean(),
612
+ addOrOverrideTalentDataBundle: z.strictObject({
613
+ candidates: z.union([
614
+ z.array(
615
+ z.strictObject({
616
+ displayRangeId: z.boolean(),
617
+ upgradeDescription: z.string(),
618
+ talentIndex: z.number(),
619
+ unlockCondition: OperatorUnlockCondZod,
620
+ requiredPotentialRank: z.number(),
621
+ prefabKey: z.string(),
622
+ name: z.union([z.string(), z.null()]),
623
+ description: z.union([z.string(), z.null()]),
624
+ rangeId: z.union([z.string(), z.null()]),
625
+ blackboard: z.array(BlackboardZod),
626
+ tokenKey: z.string().optional(),
627
+ })
628
+ ),
629
+ z.null()
630
+ ]),
631
+ }),
632
+ overrideTraitDataBundle: z.strictObject({
633
+ candidates: z.union([
634
+ z.array(
635
+ z.strictObject({
636
+ additionalDescription: z.union([z.string(), z.null()]),
637
+ unlockCondition: OperatorUnlockCondZod,
638
+ requiredPotentialRank: z.number(),
639
+ blackboard: z.array(BlackboardZod),
640
+ overrideDescripton: z.union([z.string(), z.null()]),
641
+ prefabKey: z.union([z.string(), z.null()]),
642
+ rangeId: z.union([z.string(), z.null()]),
643
+ })
644
+ ),
645
+ z.null()
646
+ ]),
647
+ }),
648
+ })
649
+ ),
650
+ attributeBlackboard: z.array(BlackboardZod),
651
+ tokenAttributeBlackboard: z.record(z.string(), z.array(BlackboardZod)),
652
+ })
653
+ ),
654
+ }),
655
+ z.null()
656
+ ]),
712
657
  });
713
- export const ParadoxIO = t.type({
714
- excel: t.type({
715
- charId: t.string,
716
- stageId: t.string,
717
- levelId: t.string,
718
- zoneId: t.string,
719
- code: t.string,
720
- name: t.string,
721
- loadingPicId: t.string,
722
- description: t.string,
723
- unlockParam: t.array(
724
- t.type({
725
- unlockType: t.number,
726
- unlockParam1: t.string,
727
- unlockParam2: t.string,
728
- unlockParam3: t.null,
658
+ export const ParadoxZod = z.strictObject({
659
+ excel: z.strictObject({
660
+ charId: z.string(),
661
+ stageId: z.string(),
662
+ levelId: z.string(),
663
+ zoneId: z.string(),
664
+ code: z.string(),
665
+ name: z.string(),
666
+ loadingPicId: z.string(),
667
+ description: z.string(),
668
+ unlockParam: z.array(
669
+ z.strictObject({
670
+ unlockType: z.string(),
671
+ unlockParam1: z.string(),
672
+ unlockParam2: z.string(),
673
+ unlockParam3: z.null(),
729
674
  })
730
675
  ),
731
- rewardItem: t.array(
732
- t.type({
733
- id: t.string,
734
- count: t.number,
735
- type: t.string,
676
+ rewardItem: z.array(
677
+ z.strictObject({
678
+ id: z.string(),
679
+ count: z.number(),
680
+ type: z.string(),
736
681
  })
737
682
  ),
738
- stageNameForShow: t.string,
739
- zoneNameForShow: t.string,
740
- picId: t.string,
741
- stageGetTime: t.number,
683
+ stageNameForShow: z.string(),
684
+ zoneNameForShow: z.string(),
685
+ picId: z.string(),
686
+ stageGetTime: z.number(),
742
687
  }),
743
- levels: StageDataIO,
688
+ levels: StageDataZod,
744
689
  });
745
- export const RogueThemeIO = t.type({
746
- name: t.string,
747
- stageDict: t.record(t.string, RogueStageIO),
748
- toughStageDict: t.record(t.string, RogueStageIO),
749
- relicDict: t.record(t.string, RogueRelicIO),
750
- variationDict: t.record(t.string, RogueVariationIO),
690
+ export const RogueThemeZod = z.strictObject({
691
+ name: z.string(),
692
+ stageDict: z.record(z.string(), RogueStageZod),
693
+ toughStageDict: z.record(z.string(), RogueStageZod),
694
+ relicDict: z.record(z.string(), RogueRelicZod),
695
+ variationDict: z.record(z.string(), RogueVariationZod),
751
696
  });
752
- export const SandboxActIO = t.type({
753
- stageDict: t.record(t.string, SandboxStageIO),
697
+ export const SandboxActZod = z.strictObject({
698
+ stageDict: z.record(z.string(), SandboxStageZod),
754
699
  });
755
- export const SkillIO = t.type({
756
- skillId: t.string,
757
- iconId: t.string,
758
- hidden: t.boolean,
759
- levels: t.array(
760
- t.type({
761
- name: t.string,
762
- rangeId: t.string,
763
- description: t.string,
764
- skillType: t.string,
765
- durationType: t.number,
766
- spData: t.type({
767
- spType: t.string,
768
- levelUpCost: t.null,
769
- maxChargeTime: t.number,
770
- spCost: t.number,
771
- initSp: t.number,
772
- increment: t.number,
700
+ export const SkillZod = z.strictObject({
701
+ skillId: z.string(),
702
+ iconId: z.union([z.string(), z.null()]),
703
+ hidden: z.boolean(),
704
+ levels: z.array(
705
+ z.strictObject({
706
+ name: z.string(),
707
+ rangeId: z.union([z.string(), z.null()]),
708
+ description: z.union([z.string(), z.null()]),
709
+ skillType: z.string(),
710
+ durationType: z.string(),
711
+ spData: z.strictObject({
712
+ spType: z.union([z.string(), z.number()]),
713
+ levelUpCost: z.null(),
714
+ maxChargeTime: z.number(),
715
+ spCost: z.number(),
716
+ initSp: z.number(),
717
+ increment: z.number(),
773
718
  }),
774
- prefabId: t.string,
775
- duration: t.number,
776
- blackboard: t.array(BlackboardIO),
719
+ prefabId: z.union([z.string(), z.null()]),
720
+ duration: z.number(),
721
+ blackboard: z.array(BlackboardZod),
777
722
  })
778
723
  ),
779
724
  });
780
- export const SkinIO = t.type({
781
- skinId: t.string,
782
- charId: t.string,
783
- tokenSkinMap: t.array(
784
- t.type({
785
- tokenId: t.string,
786
- tokenSkinId: t.string,
787
- })
788
- ),
789
- illustId: t.string,
790
- dynIllustId: t.string,
791
- avatarId: t.string,
792
- portraitId: t.string,
793
- dynPortraitId: t.string,
794
- dynEntranceId: t.string,
795
- buildingId: t.string,
796
- battleSkin: t.type({
797
- overwritePrefab: t.boolean,
798
- skinOrPrefabId: t.string,
725
+ export const SkinZod = z.strictObject({
726
+ skinId: z.string(),
727
+ charId: z.string(),
728
+ tokenSkinMap: z.union([
729
+ z.array(
730
+ z.strictObject({
731
+ tokenId: z.string(),
732
+ tokenSkinId: z.string(),
733
+ })
734
+ ),
735
+ z.null()
736
+ ]),
737
+ illustId: z.union([z.string(), z.null()]),
738
+ dynIllustId: z.union([z.string(), z.null()]),
739
+ avatarId: z.string(),
740
+ portraitId: z.union([z.string(), z.null()]),
741
+ dynPortraitId: z.union([z.string(), z.null()]),
742
+ dynEntranceId: z.union([z.string(), z.null()]),
743
+ buildingId: z.union([z.string(), z.null()]),
744
+ battleSkin: z.strictObject({
745
+ overwritePrefab: z.boolean(),
746
+ skinOrPrefabId: z.union([z.string(), z.null()]),
799
747
  }),
800
- isBuySkin: t.boolean,
801
- tmplId: t.string,
802
- voiceId: t.string,
803
- voiceType: t.string,
804
- displaySkin: t.type({
805
- skinName: t.string,
806
- colorList: t.tuple([t.string, t.string, t.string, t.string, t.string]),
807
- titleList: t.tuple([t.string, t.string]),
808
- modelName: t.string,
809
- drawerList: t.array(t.string),
810
- skinGroupId: t.string,
811
- skinGroupName: t.string,
812
- skinGroupSortIndex: t.number,
813
- content: t.string,
814
- dialog: t.string,
815
- usage: t.string,
816
- description: t.string,
817
- obtainApproach: t.string,
818
- sortId: t.number,
819
- displayTagId: t.string,
820
- getTime: t.number,
821
- onYear: t.number,
822
- onPeriod: t.number,
748
+ isBuySkin: z.boolean(),
749
+ tmplId: z.union([z.string(), z.null()]),
750
+ voiceId: z.union([z.string(), z.null()]),
751
+ voiceType: z.string(),
752
+ displaySkin: z.strictObject({
753
+ skinName: z.union([z.string(), z.null()]),
754
+ colorList: z.union([z.array(z.string()), z.null()]),
755
+ titleList: z.array(z.string()).nullable(),
756
+ modelName: z.union([z.string(), z.null()]),
757
+ drawerList: z.union([z.array(z.string()), z.null()]),
758
+ designerList: z.array(z.string()).nullable(),
759
+ skinGroupId: z.union([z.string(), z.null()]),
760
+ skinGroupName: z.union([z.string(), z.null()]),
761
+ skinGroupSortIndex: z.number(),
762
+ content: z.union([z.string(), z.null()]),
763
+ dialog: z.union([z.string(), z.null()]),
764
+ usage: z.union([z.string(), z.null()]),
765
+ description: z.union([z.string(), z.null()]),
766
+ obtainApproach: z.union([z.string(), z.null()]),
767
+ sortId: z.number(),
768
+ displayTagId: z.union([z.string(), z.null()]),
769
+ getTime: z.number(),
770
+ onYear: z.number(),
771
+ onPeriod: z.number(),
823
772
  }),
824
773
  });
825
- export const StageIO = t.type({
826
- excel: t.type({
827
- stageType: t.string,
828
- difficulty: t.string,
829
- performanceStageFlag: t.string,
830
- diffGroup: t.string,
831
- unlockCondition: t.array(
832
- t.type({
833
- stageId: t.string,
834
- completeState: t.number,
835
- })
774
+ export const StageZod = z.strictObject({
775
+ excel: z.strictObject({
776
+ stageType: z.string(),
777
+ difficulty: z.string(),
778
+ performanceStageFlag: z.string(),
779
+ diffGroup: z.string(),
780
+ unlockCondition: z.array(
781
+ z.union([
782
+ z.strictObject({
783
+ stageId: z.string(),
784
+ completeState: z.string(),
785
+ }),
786
+ z.null()
787
+ ])
836
788
  ),
837
- stageId: t.string,
838
- levelId: t.string,
839
- zoneId: t.string,
840
- code: t.string,
841
- name: t.string,
842
- description: t.string,
843
- hardStagedId: t.string,
844
- dangerLevel: t.string,
845
- dangerPoint: t.number,
846
- loadingPicId: t.string,
847
- canPractice: t.boolean,
848
- canBattleReplay: t.boolean,
849
- apCost: t.number,
850
- apFailReturn: t.number,
851
- etItemId: t.string,
852
- etCost: t.number,
853
- etFailReturn: t.number,
854
- etButtonStyle: t.string,
855
- apProtectTimes: t.number,
856
- diamondOnceDrop: t.number,
857
- practiceTicketCost: t.number,
858
- dailyStageDifficulty: t.number,
859
- expGain: t.number,
860
- goldGain: t.number,
861
- loseExpGain: t.number,
862
- loseGoldGain: t.number,
863
- passFavor: t.number,
864
- completeFavor: t.number,
865
- slProgress: t.number,
866
- displayMainItem: t.string,
867
- hilightMark: t.boolean,
868
- bossMark: t.boolean,
869
- isPredefined: t.boolean,
870
- isHardPredefined: t.boolean,
871
- isSkillSelectablePredefined: t.boolean,
872
- isStoryOnly: t.boolean,
873
- appearanceStyle: t.number,
874
- stageDropInfo: t.type({
875
- firstPassRewards: t.null,
876
- firstCompleteRewards: t.null,
877
- passRewards: t.null,
878
- completeRewards: t.null,
879
- displayRewards: t.array(
880
- t.type({
881
- type: t.string,
882
- id: t.string,
883
- dropType: t.string,
789
+ stageId: z.string(),
790
+ levelId: z.string(),
791
+ zoneId: z.string(),
792
+ code: z.string(),
793
+ name: z.string(),
794
+ description: z.string(),
795
+ hardStagedId: z.union([z.string(), z.null()]),
796
+ dangerLevel: z.union([z.string(), z.null()]),
797
+ dangerPoint: z.number(),
798
+ loadingPicId: z.string(),
799
+ canPractice: z.boolean(),
800
+ canBattleReplay: z.boolean(),
801
+ apCost: z.number(),
802
+ apFailReturn: z.number(),
803
+ etItemId: z.union([z.string(), z.null()]),
804
+ etCost: z.number(),
805
+ etFailReturn: z.number(),
806
+ etButtonStyle: z.union([z.string(), z.null()]),
807
+ apProtectTimes: z.number(),
808
+ diamondOnceDrop: z.number(),
809
+ practiceTicketCost: z.number(),
810
+ dailyStageDifficulty: z.number(),
811
+ expGain: z.number(),
812
+ goldGain: z.number(),
813
+ loseExpGain: z.number(),
814
+ loseGoldGain: z.number(),
815
+ passFavor: z.number(),
816
+ completeFavor: z.number(),
817
+ slProgress: z.number(),
818
+ displayMainItem: z.union([z.string(), z.null()]),
819
+ hilightMark: z.boolean(),
820
+ bossMark: z.boolean(),
821
+ isPredefined: z.boolean(),
822
+ isHardPredefined: z.boolean(),
823
+ isSkillSelectablePredefined: z.boolean(),
824
+ isStoryOnly: z.boolean(),
825
+ appearanceStyle: z.string(),
826
+ stageDropInfo: z.strictObject({
827
+ firstPassRewards: z.null(),
828
+ firstCompleteRewards: z.null(),
829
+ passRewards: z.null(),
830
+ completeRewards: z.null(),
831
+ displayRewards: z.array(
832
+ z.strictObject({
833
+ type: z.string(),
834
+ id: z.string(),
835
+ dropType: z.string(),
884
836
  })
885
837
  ),
886
- displayDetailRewards: t.array(
887
- t.type({
888
- occPercent: t.number,
889
- type: t.string,
890
- id: t.string,
891
- dropType: t.string,
838
+ displayDetailRewards: z.array(
839
+ z.strictObject({
840
+ occPercent: z.string(),
841
+ type: z.string(),
842
+ id: z.string(),
843
+ dropType: z.string(),
892
844
  })
893
845
  ),
894
846
  }),
895
- startButtonOverrideId: t.string,
896
- isStagePatch: t.boolean,
897
- mainStageId: t.string,
847
+ canUseCharm: z.boolean(),
848
+ canUseTech: z.boolean(),
849
+ canUseTrapTool: z.boolean(),
850
+ canUseBattlePerformance: z.boolean(),
851
+ startButtonOverrideId: z.union([z.string(), z.null()]),
852
+ isStagePatch: z.boolean(),
853
+ mainStageId: z.union([z.string(), z.null()]),
854
+ extraCondition: z.union([
855
+ z.array(
856
+ z.strictObject({
857
+ index: z.number(),
858
+ template: z.string(),
859
+ unlockParam: z.array(z.string()),
860
+ })
861
+ ),
862
+ z.null()
863
+ ]),
864
+ extraInfo: z.union([
865
+ z.array(
866
+ z.strictObject({
867
+ stageId: z.string(),
868
+ rewards: z.array(
869
+ z.strictObject({
870
+ id: z.string(),
871
+ count: z.number(),
872
+ type: z.string(),
873
+ })
874
+ ),
875
+ progressInfo: z.strictObject({
876
+ progressType: z.string(),
877
+ descList: z.record(z.string(), z.string()),
878
+ })
879
+ })
880
+ ),
881
+ z.null()
882
+ ])
898
883
  }),
899
- levels: StageDataIO,
884
+ levels: StageDataZod,
900
885
  });
901
- export const OperatorIO = t.type({
902
- id: t.string,
903
- recruit: t.number,
904
- archetype: t.string,
905
- range: GridRangeIO,
906
- skills: t.array(SkillIO),
907
- modules: t.array(ModuleIO),
908
- skins: t.array(SkinIO),
909
- bases: t.array(
910
- t.type({
911
- condition: t.type({
912
- buffId: t.string,
913
- cond: OperatorUnlockCondIO,
886
+ export const OperatorZod = z.strictObject({
887
+ id: z.string(),
888
+ recruit: z.number(),
889
+ archetype: z.string(),
890
+ range: GridRangeZod,
891
+ skills: z.array(SkillZod),
892
+ modules: z.array(ModuleZod),
893
+ skins: z.array(SkinZod),
894
+ bases: z.array(
895
+ z.strictObject({
896
+ condition: z.strictObject({
897
+ buffId: z.string(),
898
+ cond: OperatorUnlockCondZod,
914
899
  }),
915
- skill: BaseIO,
900
+ skill: BaseZod,
916
901
  })
917
902
  ),
918
- paradox: ParadoxIO,
919
- data: t.type({
920
- name: t.string,
921
- description: t.string,
922
- canUseGeneralPotentialItem: t.boolean,
923
- potentialItemId: t.string,
924
- nationId: t.string,
925
- groupId: t.string,
926
- teamId: t.string,
927
- displayNumber: t.string,
928
- tokenKey: t.string,
929
- appellation: t.string,
930
- position: t.string,
931
- tagList: t.array(t.string),
932
- itemUsage: t.string,
933
- itemDesc: t.string,
934
- itemObtainApproach: t.string,
935
- isNotObtainable: t.boolean,
936
- isSpChar: t.boolean,
937
- maxPotentialLevel: t.number,
938
- rarity: t.string,
939
- profession: t.string,
940
- subProfessionId: t.string,
941
- trait: t.type({
942
- candidates: t.array(
943
- t.type({
944
- unlockCondition: OperatorUnlockCondIO,
945
- requiredPotentialRank: t.number,
946
- blackboard: t.array(BlackboardIO),
947
- overrideDescripton: t.string,
948
- prefabKey: t.string,
949
- rangeId: t.string,
950
- })
951
- ),
952
- }),
953
- phases: t.array(
954
- t.type({
955
- characterPrefabKey: t.string,
956
- rangeId: t.string,
957
- maxLevel: t.number,
958
- attributesKeyFrames: t.array(AttributesKeyFrameIO),
959
- evolveCost: t.array(LevelUpCostIO),
960
- })
961
- ),
962
- skills: t.array(
963
- t.type({
964
- skillId: t.string,
965
- overridePrefabKey: t.string,
966
- overrideTokenKey: t.string,
967
- levelUpCostCond: t.array(LevelUpCostCondIO),
968
- unlockCond: OperatorUnlockCondIO,
969
- })
970
- ),
971
- talents: t.array(
972
- t.type({
973
- candidates: t.array(
974
- t.type({
975
- unlockCondition: OperatorUnlockCondIO,
976
- requiredPotentialRank: t.number,
977
- prefabKey: t.string,
978
- name: t.string,
979
- description: t.string,
980
- rangeId: t.string,
981
- blackboard: t.array(BlackboardIO),
903
+ paradox: z.union([ParadoxZod, z.null()]),
904
+ data: z.strictObject({
905
+ name: z.string(),
906
+ description: z.string(),
907
+ canUseGeneralPotentialItem: z.boolean(),
908
+ canUseActivityPotentialItem: z.boolean(),
909
+ potentialItemId: z.union([z.string(), z.null()]),
910
+ activityPotentialItemId: z.string().nullable(),
911
+ classicPotentialItemId: z.string().nullable(),
912
+ nationId: z.union([z.string(), z.null()]),
913
+ groupId: z.union([z.string(), z.null()]),
914
+ teamId: z.union([z.string(), z.null()]),
915
+ displayNumber: z.union([z.string(), z.null()]),
916
+ appellation: z.string(),
917
+ position: z.string(),
918
+ tagList: z.array(z.string()),
919
+ itemUsage: z.union([z.string(), z.null()]),
920
+ itemDesc: z.union([z.string(), z.null()]),
921
+ itemObtainApproach: z.union([z.string(), z.null()]),
922
+ isNotObtainable: z.boolean(),
923
+ isSpChar: z.boolean(),
924
+ maxPotentialLevel: z.number(),
925
+ rarity: z.string(),
926
+ profession: z.string(),
927
+ subProfessionId: z.string(),
928
+ trait: z.union([
929
+ z.strictObject({
930
+ candidates: z.array(
931
+ z.strictObject({
932
+ unlockCondition: OperatorUnlockCondZod,
933
+ requiredPotentialRank: z.number(),
934
+ blackboard: z.array(BlackboardZod),
935
+ overrideDescripton: z.union([z.string(), z.null()]),
936
+ prefabKey: z.union([z.string(), z.null()]),
937
+ rangeId: z.union([z.string(), z.null()]),
982
938
  })
983
939
  ),
940
+ }),
941
+ z.null()
942
+ ]),
943
+ phases: z.array(
944
+ z.strictObject({
945
+ characterPrefabKey: z.string(),
946
+ rangeId: z.string(),
947
+ maxLevel: z.number(),
948
+ attributesKeyFrames: z.array(AttributesKeyFrameZod),
949
+ evolveCost: z.union([z.array(LevelUpCostZod), z.null()]),
950
+ })
951
+ ),
952
+ skills: z.array(
953
+ z.strictObject({
954
+ skillId: z.string(),
955
+ overridePrefabKey: z.union([z.string(), z.null()]),
956
+ overrideTokenKey: z.union([z.string(), z.null()]),
957
+ levelUpCostCond: z.array(LevelUpCostCondZod),
958
+ unlockCond: OperatorUnlockCondZod,
984
959
  })
985
960
  ),
986
- potentialRanks: t.array(
987
- t.type({
988
- type: t.number,
989
- description: t.string,
990
- buff: t.type({
991
- attributes: t.type({
992
- abnormalFlags: t.null,
993
- abnormalImmunes: t.null,
994
- abnormalAntis: t.null,
995
- abnormalCombos: t.null,
996
- abnormalComboImmunes: t.null,
997
- attributeModifiers: t.array(
998
- t.type({
999
- attributeType: t.number,
1000
- formulaItem: t.number,
1001
- value: t.number,
1002
- loadFromBlackboard: t.boolean,
1003
- fetchBaseValueFromSourceEntity: t.boolean,
1004
- })
1005
- ),
961
+ displayTokenDict: z.record(z.boolean()).nullable(),
962
+ talents: z.union([
963
+ z.array(
964
+ z.strictObject({
965
+ candidates: z.array(
966
+ z.strictObject({
967
+ unlockCondition: OperatorUnlockCondZod,
968
+ requiredPotentialRank: z.number(),
969
+ prefabKey: z.string(),
970
+ name: z.string(),
971
+ description: z.string(),
972
+ rangeId: z.union([z.string(), z.null()]),
973
+ blackboard: z.array(BlackboardZod),
974
+ tokenKey: z.string().nullable(),
975
+ })
976
+ ),
977
+ })
978
+ ),
979
+ z.null()
980
+ ]),
981
+ potentialRanks: z.array(
982
+ z.strictObject({
983
+ type: z.string(),
984
+ description: z.string(),
985
+ buff: z.union([
986
+ z.strictObject({
987
+ attributes: z.strictObject({
988
+ abnormalFlags: z.null(),
989
+ abnormalImmunes: z.null(),
990
+ abnormalAntis: z.null(),
991
+ abnormalCombos: z.null(),
992
+ abnormalComboImmunes: z.null(),
993
+ attributeModifiers: z.array(
994
+ z.strictObject({
995
+ attributeType: z.string(),
996
+ formulaItem: z.string(),
997
+ value: z.number(),
998
+ loadFromBlackboard: z.boolean(),
999
+ fetchBaseValueFromSourceEntity: z.boolean(),
1000
+ })
1001
+ ),
1002
+ }),
1006
1003
  }),
1007
- }),
1008
- equivalentCost: t.null,
1004
+ z.null()
1005
+ ]),
1006
+ equivalentCost: z.null(),
1009
1007
  })
1010
1008
  ),
1011
- favorKeyFrames: t.array(AttributesKeyFrameIO),
1012
- allSkillLvlup: t.array(
1013
- t.type({
1014
- unlockCond: OperatorUnlockCondIO,
1015
- lvlUpCost: t.array(LevelUpCostIO),
1009
+ favorKeyFrames: z.array(AttributesKeyFrameZod),
1010
+ allSkillLvlup: z.array(
1011
+ z.strictObject({
1012
+ unlockCond: OperatorUnlockCondZod,
1013
+ lvlUpCost: z.union([z.array(LevelUpCostZod), z.null()]),
1016
1014
  })
1017
1015
  ),
1018
1016
  }),
1019
1017
  });
1020
- export type AttributesKeyFrame = t.TypeOf<typeof AttributesKeyFrameIO>;
1021
- export type Blackboard = t.TypeOf<typeof BlackboardIO>;
1022
- export type Base = t.TypeOf<typeof BaseIO>;
1023
- export type CCStage = t.TypeOf<typeof CCStageIO>;
1024
- export type Definition = t.TypeOf<typeof DefinitionIO>;
1025
- export type Enemy = t.TypeOf<typeof EnemyIO>;
1026
- export type EnemyAttributes = t.TypeOf<typeof EnemyAttributesIO>;
1027
- export type EnemySkills = t.TypeOf<typeof EnemySkillsIO>;
1028
- export type EnemySpData = t.TypeOf<typeof EnemySpDataIO>;
1029
- export type GameEvent = t.TypeOf<typeof GameEventIO>;
1030
- export type GridRange = t.TypeOf<typeof GridRangeIO>;
1031
- export type ManufactFormula = t.TypeOf<typeof ManufactFormulaIO>;
1032
- export type WorkshopFormula = t.TypeOf<typeof WorkshopFormulaIO>;
1033
- export type Item = t.TypeOf<typeof ItemIO>;
1034
- export type LevelUpCost = t.TypeOf<typeof LevelUpCostIO>;
1035
- export type LevelUpCostCond = t.TypeOf<typeof LevelUpCostCondIO>;
1036
- export type Module = t.TypeOf<typeof ModuleIO>;
1037
- export type Operator = t.TypeOf<typeof OperatorIO>;
1038
- export type OperatorUnlockCond = t.TypeOf<typeof OperatorUnlockCondIO>;
1039
- export type Paradox = t.TypeOf<typeof ParadoxIO>;
1040
- export type RogueTheme = t.TypeOf<typeof RogueThemeIO>;
1041
- export type RogueRelic = t.TypeOf<typeof RogueRelicIO>;
1042
- export type RogueStage = t.TypeOf<typeof RogueStageIO>;
1043
- export type RogueVariation = t.TypeOf<typeof RogueVariationIO>;
1044
- export type SandboxAct = t.TypeOf<typeof SandboxActIO>;
1045
- export type SandboxStage = t.TypeOf<typeof SandboxStageIO>;
1046
- export type Skill = t.TypeOf<typeof SkillIO>;
1047
- export type Skin = t.TypeOf<typeof SkinIO>;
1048
- export type Stage = t.TypeOf<typeof StageIO>;
1049
- export type StageData = t.TypeOf<typeof StageDataIO>;
1050
- export type StageEffect = t.TypeOf<typeof StageEffectIO>;
1051
- export type StageDefines = t.TypeOf<typeof StageDefinesIO>;
1018
+ export type AttributesKeyFrame = z.infer<typeof AttributesKeyFrameZod>;
1019
+ export type Blackboard = z.infer<typeof BlackboardZod>;
1020
+ export type Base = z.infer<typeof BaseZod>;
1021
+ export type CCStage = z.infer<typeof CCStageZod>;
1022
+ export type Definition = z.infer<typeof DefinitionZod>;
1023
+ export type Enemy = z.infer<typeof EnemyZod>;
1024
+ export type EnemyAttributes = z.infer<typeof EnemyAttributesZod>;
1025
+ export type EnemyData = z.infer<typeof EnemyDataZod>;
1026
+ export type EnemySkills = z.infer<typeof EnemySkillsZod>;
1027
+ export type EnemySpData = z.infer<typeof EnemySpDataZod>;
1028
+ export type GameEvent = z.infer<typeof GameEventZod>;
1029
+ export type GridRange = z.infer<typeof GridRangeZod>;
1030
+ export type ManufactFormula = z.infer<typeof ManufactFormulaZod>;
1031
+ export type WorkshopFormula = z.infer<typeof WorkshopFormulaZod>;
1032
+ export type Item = z.infer<typeof ItemZod>;
1033
+ export type LevelUpCost = z.infer<typeof LevelUpCostZod>;
1034
+ export type LevelUpCostCond = z.infer<typeof LevelUpCostCondZod>;
1035
+ export type Module = z.infer<typeof ModuleZod>;
1036
+ export type Operator = z.infer<typeof OperatorZod>;
1037
+ export type OperatorUnlockCond = z.infer<typeof OperatorUnlockCondZod>;
1038
+ export type Paradox = z.infer<typeof ParadoxZod>;
1039
+ export type RogueTheme = z.infer<typeof RogueThemeZod>;
1040
+ export type RogueRelic = z.infer<typeof RogueRelicZod>;
1041
+ export type RogueStage = z.infer<typeof RogueStageZod>;
1042
+ export type RogueVariation = z.infer<typeof RogueVariationZod>;
1043
+ export type SandboxAct = z.infer<typeof SandboxActZod>;
1044
+ export type SandboxStage = z.infer<typeof SandboxStageZod>;
1045
+ export type Skill = z.infer<typeof SkillZod>;
1046
+ export type Skin = z.infer<typeof SkinZod>;
1047
+ export type Stage = z.infer<typeof StageZod>;
1048
+ export type StageData = z.infer<typeof StageDataZod>;
1049
+ export type StageEffect = z.infer<typeof StageEffectZod>;
1050
+ export type StageDefines = z.infer<typeof StageDefinesZod>;