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