hella-types 0.0.6 → 0.0.7

package/dist/index.js

@@ -1,7 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OperatorIO = exports.StageIO = exports.SkinIO = exports.SkillIO = exports.SandboxActIO = exports.RogueThemeIO = exports.ParadoxIO = exports.ModuleIO = exports.ItemIO = exports.GameEventIO = exports.EnemyIO = exports.DefinitionIO = exports.CCStageIO = exports.BaseIO = exports.SandboxStageIO = exports.RogueVariationIO = exports.RogueStageIO = exports.RogueRelicIO = exports.StageDataIO = exports.StageEffectIO = exports.StageDefinesIO = exports.LevelUpCostCondIO = exports.OperatorUnlockCondIO = exports.WorkshopFormulaIO = exports.ManufactFormulaIO = exports.LevelUpCostIO = exports.GridRangeIO = exports.EnemySpDataIO = exports.EnemySkillsIO = exports.EnemyAttributesIO = exports.BlackboardIO = exports.AttributesKeyFrameIO = void 0;
+exports.OperatorIO = exports.StageIO = exports.SkinIO = exports.SkillIO = exports.SandboxActIO = exports.RogueThemeIO = exports.ParadoxIO = exports.ModuleIO = exports.ItemIO = exports.GameEventIO = exports.EnemyIO = exports.DefinitionIO = exports.CCStageIO = exports.BaseIO = exports.SandboxStageIO = exports.RogueVariationIO = exports.RogueStageIO = exports.RogueRelicIO = exports.StageDataIO = exports.StageActionIO = exports.StageEffectIO = exports.StageDefinesIO = exports.LevelUpCostCondIO = exports.OperatorUnlockCondIO = exports.WorkshopFormulaIO = exports.ManufactFormulaIO = exports.LevelUpCostIO = exports.GridRangeIO = exports.EnemyData = exports.EnemySpDataIO = exports.EnemySkillsIO = exports.EnemyAttributesIO = exports.BlackboardIO = exports.AttributesKeyFrameIO = void 0;
 var t = require("io-ts");
+var stringIO = t.type({
+    m_defined: t.boolean,
+    m_value: t.union([t.string, t.null]),
+});
+var stringArrayIO = t.type({
+    m_defined: t.boolean,
+    m_value: t.union([t.array(t.string), t.null]),
+});
+var numberIO = t.type({
+    m_defined: t.boolean,
+    m_value: t.union([t.number, t.null]),
+});
+var booleanIO = t.type({
+    m_defined: t.boolean,
+    m_value: t.boolean,
+});
 exports.AttributesKeyFrameIO = t.type({
     level: t.number,
     data: t.type({
@@ -31,94 +47,33 @@ exports.AttributesKeyFrameIO = t.type({
 });
 exports.BlackboardIO = t.type({
     key: t.string,
-    value: t.union([t.number, t.undefined]),
-    valueStr: t.union([t.string, t.undefined]),
+    value: t.union([t.number, t.null]),
+    valueStr: t.union([t.string, t.null, t.undefined]),
 });
 exports.EnemyAttributesIO = t.type({
-    maxHp: t.type({
-        m_defined: t.boolean,
-        m_value: t.number,
-    }),
-    atk: t.type({
-        m_defined: t.boolean,
-        m_value: t.number,
-    }),
-    def: t.type({
-        m_defined: t.boolean,
-        m_value: t.number,
-    }),
-    magicResistance: t.type({
-        m_defined: t.boolean,
-        m_value: t.number,
-    }),
-    cost: t.type({
-        m_defined: t.boolean,
-        m_value: t.number,
-    }),
-    blockCnt: t.type({
-        m_defined: t.boolean,
-        m_value: t.number,
-    }),
-    moveSpeed: t.type({
-        m_defined: t.boolean,
-        m_value: t.number,
-    }),
-    attackSpeed: t.type({
-        m_defined: t.boolean,
-        m_value: t.number,
-    }),
-    baseAttackTime: t.type({
-        m_defined: t.boolean,
-        m_value: t.number,
-    }),
-    respawnTime: t.type({
-        m_defined: t.boolean,
-        m_value: t.number,
-    }),
-    hpRecoveryPerSec: t.type({
-        m_defined: t.boolean,
-        m_value: t.number,
-    }),
-    spRecoveryPerSec: t.type({
-        m_defined: t.boolean,
-        m_value: t.number,
-    }),
-    maxDeployCount: t.type({
-        m_defined: t.boolean,
-        m_value: t.number,
-    }),
-    massLevel: t.type({
-        m_defined: t.boolean,
-        m_value: t.number,
-    }),
-    baseForceLevel: t.type({
-        m_defined: t.boolean,
-        m_value: t.number,
-    }),
-    tauntLevel: t.type({
-        m_defined: t.boolean,
-        m_value: t.number,
-    }),
-    stunImmune: t.type({
-        m_defined: t.boolean,
-        m_value: t.boolean,
-    }),
-    silenceImmune: t.type({
-        m_defined: t.boolean,
-        m_value: t.boolean,
-    }),
-    sleepImmune: t.type({
-        m_defined: t.boolean,
-        m_value: t.boolean,
-    }),
-    frozenImmune: t.type({
-        m_defined: t.boolean,
-        m_value: t.boolean,
-    }),
-    levitateImmune: t.type({
-        m_defined: t.boolean,
-        m_value: t.boolean,
-    }),
+    maxHp: numberIO,
+    atk: numberIO,
+    def: numberIO,
+    magicResistance: numberIO,
+    cost: numberIO,
+    blockCnt: numberIO,
+    moveSpeed: numberIO,
+    attackSpeed: numberIO,
+    baseAttackTime: numberIO,
+    respawnTime: numberIO,
+    hpRecoveryPerSec: numberIO,
+    spRecoveryPerSec: numberIO,
+    maxDeployCount: numberIO,
+    massLevel: numberIO,
+    baseForceLevel: numberIO,
+    tauntLevel: t.union([numberIO, t.undefined]), // legacy
+    epDamageResistance: t.union([numberIO, t.undefined]), // legacy
+    epResistance: t.union([numberIO, t.undefined]), // ~
+    stunImmune: booleanIO,
+    silenceImmune: booleanIO,
+    sleepImmune: t.union([booleanIO, t.undefined]),
+    frozenImmune: t.union([booleanIO, t.undefined]), // legacy
+    levitateImmune: t.union([booleanIO, t.undefined]), // legacy
 });
 exports.EnemySkillsIO = t.type({
     prefabKey: t.string,
@@ -126,14 +81,32 @@ exports.EnemySkillsIO = t.type({
     cooldown: t.number,
     initCooldown: t.number,
     spCost: t.number,
-    blackboard: t.array(exports.BlackboardIO),
+    blackboard: t.union([t.array(exports.BlackboardIO), t.null]),
 });
 exports.EnemySpDataIO = t.type({
-    spType: t.number,
+    spType: t.string,
     maxSp: t.number,
     initSp: t.number,
     increment: t.number,
 });
+exports.EnemyData = t.type({
+    name: stringIO,
+    description: stringIO,
+    prefabKey: stringIO,
+    attributes: exports.EnemyAttributesIO,
+    applyWay: t.union([stringIO, t.undefined]), // legacy
+    motion: t.union([stringIO, t.undefined]), // legacy
+    enemyTags: t.union([stringArrayIO, t.undefined]), // legacy
+    lifePointReduce: numberIO,
+    levelType: t.union([stringIO, numberIO, t.undefined]), // legacy
+    rangeRadius: numberIO,
+    numOfExtraDrops: t.union([numberIO, t.undefined]), // legacy
+    viewRadius: t.union([numberIO, t.undefined]), // legacy
+    notCountInTotal: t.union([booleanIO, t.undefined]), // legacy
+    talentBlackboard: t.union([t.array(exports.BlackboardIO), t.null]),
+    skills: t.union([t.array(exports.EnemySkillsIO), t.null]),
+    spData: t.union([exports.EnemySpDataIO, t.null]),
+});
 exports.GridRangeIO = t.type({
     id: t.string,
     direction: t.number,
@@ -194,13 +167,13 @@ exports.WorkshopFormulaIO = t.type({
     })),
 });
 exports.OperatorUnlockCondIO = t.type({
-    phase: t.string,
+    phase: t.union([t.string, t.number]),
     level: t.number,
 });
 exports.LevelUpCostCondIO = t.type({
     unlockCond: exports.OperatorUnlockCondIO,
     lvlUpTime: t.number,
-    levelUpCost: t.array(exports.LevelUpCostIO),
+    levelUpCost: t.union([t.array(exports.LevelUpCostIO), t.null]),
 });
 exports.StageDefinesIO = t.type({
     characterInsts: t.array(t.any),
@@ -209,25 +182,29 @@ exports.StageDefinesIO = t.type({
             row: t.number,
             col: t.number,
         }),
-        direction: t.number,
+        direction: t.union([t.string, t.number]), // legacy
         hidden: t.boolean,
-        alias: t.string,
-        uniEquipIds: t.array(t.type({
-            key: t.string,
-            level: t.number,
-        })),
+        alias: t.union([t.string, t.null]),
+        uniEquipIds: t.union([
+            t.array(t.type({
+                key: t.string,
+                level: t.number,
+            })),
+            t.null, t.undefined
+        ] // legacy
+        ),
         inst: t.type({
             characterKey: t.string,
             level: t.number,
-            phase: t.number,
+            phase: t.union([t.string, t.number]), // legacy
             favorPoint: t.number,
             potentialRank: t.number,
         }),
         skillIndex: t.number,
         mainSkillLvl: t.number,
-        skinId: t.string,
-        tmplId: t.string,
-        overrideSkillBlackboard: t.array(exports.BlackboardIO),
+        skinId: t.union([t.string, t.null]),
+        tmplId: t.union([t.string, t.null, t.undefined]),
+        overrideSkillBlackboard: t.union([t.array(exports.BlackboardIO), t.null, t.undefined]),
     })),
     characterCards: t.array(t.any),
     tokenCards: t.array(t.any),
@@ -239,7 +216,31 @@ exports.StageEffectIO = t.type({
         y: t.number,
         z: t.number,
     }),
-    direction: t.number,
+    direction: t.union([t.string, t.number]), // legacy
+});
+exports.StageActionIO = t.type({
+    preDelay: t.number,
+    actions: t.array(t.type({
+        actionType: t.union([t.string, t.number]), // legacy
+        managedByScheduler: t.boolean,
+        key: t.string,
+        count: t.number,
+        preDelay: t.number,
+        interval: t.number,
+        routeIndex: t.number,
+        blockFragment: t.boolean,
+        autoPreviewRoute: t.boolean,
+        autoDisplayEnemyInfo: t.union([t.boolean, t.undefined]), // legacy
+        isUnharmfulAndAlwaysCountAsKilled: t.boolean,
+        hiddenGroup: t.union([t.string, t.null]),
+        randomSpawnGroupKey: t.union([t.string, t.null, t.undefined]), // legacy
+        randomSpawnGroupPackKey: t.union([t.string, t.null, t.undefined]), // legacy
+        randomType: t.union([t.string, t.number, t.undefined]), // legacy
+        weight: t.union([t.number, t.undefined]), // legacy
+        dontBlockWave: t.union([t.boolean, t.undefined]), // legacy
+        isValid: t.union([t.boolean, t.undefined]), // legacy
+        extraMeta: t.union([t.null, t.undefined]), // legacy
+    })),
 });
 exports.StageDataIO = t.type({
     options: t.type({
@@ -251,174 +252,128 @@ exports.StageDataIO = t.type({
         moveMultiplier: t.number,
         steeringEnabled: t.boolean,
         isTrainingLevel: t.boolean,
-        isHardTrainingLevel: t.boolean,
-        functionDisableMask: t.number,
-    }),
-    levelId: t.string,
-    mapId: t.string,
-    bgmEvent: t.string,
-    environmentSe: t.string,
+        isHardTrainingLevel: t.union([t.boolean, t.undefined]), // legacy
+        isPredefinedCardsSelectable: t.union([t.boolean, t.undefined]), // legacy
+        maxPlayTime: t.union([t.number, t.undefined]), // legacy
+        functionDisableMask: t.union([t.string, t.number]),
+        configBlackBoard: t.union([t.array(exports.BlackboardIO), t.null, t.undefined]), // legacy
+    }),
+    levelId: t.union([t.string, t.null]),
+    mapId: t.union([t.string, t.null]),
+    bgmEvent: t.union([t.string, t.null]),
+    environmentSe: t.union([t.string, t.null]),
     mapData: t.type({
         map: t.array(t.array(t.number)),
         tiles: t.array(t.type({
             tileKey: t.string,
-            heightType: t.number,
-            buildableType: t.number,
-            passableMask: t.number,
-            playerSideMask: t.number,
-            blackboard: exports.BlackboardIO,
-            effects: t.array(exports.StageEffectIO),
+            heightType: t.union([t.string, t.number]), // keep number for legacy stages (monster hunter, vignettes, etc.)
+            buildableType: t.union([t.string, t.number]), // ~
+            passableMask: t.union([t.string, t.number]), // ~
+            playerSideMask: t.union([t.string, t.number, t.undefined]), // ~
+            blackboard: t.union([t.array(exports.BlackboardIO), t.null]),
+            effects: t.union([t.array(exports.StageEffectIO), t.null]),
         })),
-        blockEdges: t.null,
-        tags: t.array(t.string),
-        effects: t.array(exports.StageEffectIO),
-        layerRects: t.array(t.string),
-        width: t.number,
-        height: t.number,
+        blockEdges: t.union([t.array(t.any), t.null]),
+        tags: t.union([t.array(t.string), t.null]),
+        effects: t.union([t.array(exports.StageEffectIO), t.null]),
+        layerRects: t.union([t.null, t.undefined]),
     }),
     tilesDisallowToLocate: t.array(t.any),
-    runes: t.array(t.type({
-        difficultyMask: t.number,
-        key: t.string,
-        professionMask: t.number,
-        buildableMask: t.number,
-        blackboard: t.array(exports.BlackboardIO),
-    })),
-    globalBuffs: t.array(t.type({
-        prefabKey: t.string,
-        blackboard: t.array(exports.BlackboardIO),
-        overrideCameraEffect: t.null,
-        passProfessionMaskFlag: t.boolean,
-        professionMask: t.number,
-    })),
-    routes: t.array(t.type({
-        motionMode: t.number,
-        startPosition: t.type({
-            row: t.number,
-            col: t.number,
-        }),
-        endPosition: t.type({
-            row: t.number,
-            col: t.number,
-        }),
-        spawnRandomRange: t.type({
-            x: t.number,
-            y: t.number,
-        }),
-        spawnOffset: t.type({
-            x: t.number,
-            y: t.number,
-        }),
-        checkpoints: t.array(t.type({
-            type: t.number,
-            time: t.number,
-            position: t.type({
+    runes: t.union([
+        t.array(t.type({
+            difficultyMask: t.union([t.string, t.number]), // legacy
+            key: t.string,
+            professionMask: t.union([t.string, t.number, t.undefined]), // legacy
+            buildableMask: t.union([t.string, t.number]), // legacy
+            blackboard: t.array(exports.BlackboardIO),
+        })),
+        t.null
+    ]),
+    globalBuffs: t.union([
+        t.array(t.type({
+            prefabKey: t.string,
+            blackboard: t.union([t.array(exports.BlackboardIO), t.null]),
+            overrideCameraEffect: t.null,
+            passProfessionMaskFlag: t.union([t.boolean, t.undefined]),
+            professionMask: t.union([t.string, t.number, t.undefined]),
+        })),
+        t.null
+    ]),
+    routes: t.array(t.union([
+        t.type({
+            motionMode: t.union([t.string, t.number]), // keep number for legacy
+            startPosition: t.type({
                 row: t.number,
                 col: t.number,
             }),
-            reachOffset: t.type({
+            endPosition: t.type({
+                row: t.number,
+                col: t.number,
+            }),
+            spawnRandomRange: t.type({
                 x: t.number,
                 y: t.number,
             }),
-            randomizeReachOffset: t.boolean,
-            reachDistance: t.number,
-        })),
-        allowDiagonalMove: t.boolean,
-        visitEveryTileCenter: t.boolean,
-        visitEveryNodeCenter: t.boolean,
-        visitEveryCheckPoint: t.boolean,
-    })),
-    extraRoutes: t.array(t.any),
+            spawnOffset: t.type({
+                x: t.number,
+                y: t.number,
+            }),
+            checkpoints: t.union([
+                t.array(t.type({
+                    type: t.union([t.string, t.number]), // keep number for legacy
+                    time: t.number,
+                    position: t.type({
+                        row: t.number,
+                        col: t.number,
+                    }),
+                    reachOffset: t.type({
+                        x: t.number,
+                        y: t.number,
+                    }),
+                    randomizeReachOffset: t.boolean,
+                    reachDistance: t.number,
+                })),
+                t.null
+            ]),
+            allowDiagonalMove: t.boolean,
+            visitEveryTileCenter: t.boolean,
+            visitEveryNodeCenter: t.boolean,
+            visitEveryCheckPoint: t.union([t.boolean, t.undefined]), // legacy
+        }),
+        t.null // legacy
+    ])),
+    extraRoutes: t.union([t.array(t.any), t.undefined]),
     enemies: t.array(t.any),
     enemyDbRefs: t.array(t.type({
         useDb: t.boolean,
         id: t.string,
         level: t.number,
-        overwrittenData: t.type({
-            name: t.type({
-                m_defined: t.boolean,
-                m_value: t.number,
-            }),
-            description: t.type({
-                m_defined: t.boolean,
-                m_value: t.number,
-            }),
-            prefabKey: t.type({
-                m_defined: t.boolean,
-                m_value: t.number,
-            }),
-            attributes: exports.EnemyAttributesIO,
-            lifePointReduce: t.type({
-                m_defined: t.boolean,
-                m_value: t.number,
-            }),
-            rangeRadius: t.type({
-                m_defined: t.boolean,
-                m_value: t.number,
-            }),
-            talentBlackboard: t.array(exports.BlackboardIO),
-            skills: t.array(exports.EnemySkillsIO),
-            spData: exports.EnemySpDataIO,
-        }),
+        overwrittenData: t.union([exports.EnemyData, t.null]),
     })),
     waves: t.array(t.type({
         preDelay: t.number,
         postDelay: t.number,
         maxTimeWaitingForNextWave: t.number,
-        fragments: t.array(t.type({
-            preDelay: t.number,
-            actions: t.array(t.type({
-                actionType: t.number,
-                managedByScheduler: t.boolean,
-                key: t.string,
-                count: t.number,
-                preDelay: t.number,
-                interval: t.number,
-                routeIndex: t.number,
-                blockFragment: t.boolean,
-                autoPreviewRoute: t.boolean,
-                isUnharmfulAndAlwaysCountAsKilled: t.boolean,
-                hiddenGroup: t.string,
-                randomSpawnGroupKey: t.string,
-                weight: t.number,
-                dontBlockWave: t.boolean,
-            })),
-            name: t.string,
-        })),
+        fragments: t.array(exports.StageActionIO),
+        advancedWaveTag: t.union([t.string, t.null, t.undefined]), // legacy
     })),
-    branches: t.type({
-        frosts: t.type({
-            phases: t.array(t.type({
-                preDelay: t.number,
-                actions: t.array(t.type({
-                    actionType: t.number,
-                    managedByScheduler: t.boolean,
-                    key: t.string,
-                    count: t.number,
-                    preDelay: t.number,
-                    interval: t.number,
-                    routeIndex: t.number,
-                    blockFragment: t.boolean,
-                    autoPreviewRoute: t.boolean,
-                    isUnharmfulAndAlwaysCountAsKilled: t.boolean,
-                    hiddenGroup: t.string,
-                    randomSpawnGroupKey: t.string,
-                    weight: t.number,
-                    weightValue: t.number,
-                })),
-            })),
-        }),
-    }),
-    predefines: exports.StageDefinesIO,
-    hardPredefines: exports.StageDefinesIO,
+    branches: t.union([
+        t.record(t.string, t.type({
+            phases: t.array(exports.StageActionIO),
+        })),
+        t.null
+    ]),
+    predefines: t.union([exports.StageDefinesIO, t.null]),
+    hardPredefines: t.union([exports.StageDefinesIO, t.null, t.undefined]),
     excludeCharIdList: t.null,
     randomSeed: t.number,
-    operaConfig: t.string,
+    operaConfig: t.union([t.string, t.null, t.undefined]),
+    runtimeData: t.union([t.null, t.undefined]), // legacy
 });
 exports.RogueRelicIO = t.type({
     id: t.string,
     name: t.string,
-    description: t.string,
+    description: t.union([t.string, t.null]),
     usage: t.string,
     obtainApproach: t.string,
     iconId: t.string,
@@ -428,7 +383,7 @@ exports.RogueRelicIO = t.type({
     value: t.number,
     sortId: t.number,
     canSacrifice: t.boolean,
-    unlockCondDesc: t.string,
+    unlockCondDesc: t.union([t.string, t.null]),
 });
 exports.RogueStageIO = t.type({
     excel: t.type({
@@ -439,11 +394,11 @@ exports.RogueStageIO = t.type({
         name: t.string,
         loadingPicId: t.string,
         description: t.string,
-        eliteDesc: t.string,
+        eliteDesc: t.union([t.string, t.null]),
         isBoss: t.number,
         isElite: t.number,
         difficulty: t.string,
-        capsulePool: t.string,
+        capsulePool: t.union([t.string, t.null]),
         capsuleProb: t.number,
         vutresProb: t.array(t.number),
         boxProb: t.array(t.number),
@@ -457,8 +412,8 @@ exports.RogueVariationIO = t.type({
     innerName: t.string,
     functionDesc: t.string,
     desc: t.string,
-    iconId: t.string,
-    sound: t.string,
+    iconId: t.union([t.string, t.null]),
+    sound: t.union([t.string, t.null]),
 });
 exports.SandboxStageIO = t.type({
     excel: t.type({
@@ -503,18 +458,13 @@ exports.EnemyIO = t.type({
     excel: t.type({
         enemyId: t.string,
         enemyIndex: t.string,
-        enemyTags: t.array(t.string),
+        enemyTags: t.union([t.array(t.string), t.null]),
         sortId: t.number,
         name: t.string,
-        enemyRace: t.string,
         enemyLevel: t.string,
         description: t.string,
-        attackType: t.string,
-        endure: t.string,
-        attack: t.string,
-        defence: t.string,
-        resistance: t.string,
-        ability: t.string,
+        attackType: t.null,
+        ability: t.null,
         isInvalidKilled: t.boolean,
         overrideKillCntInfos: t.record(t.string, t.any),
         hideInHandbook: t.boolean,
@@ -523,40 +473,7 @@ exports.EnemyIO = t.type({
         Key: t.string,
         Value: t.array(t.type({
             level: t.number,
-            enemyData: t.type({
-                name: t.type({
-                    m_defined: t.boolean,
-                    m_value: t.string,
-                }),
-                description: t.type({
-                    m_defined: t.boolean,
-                    m_value: t.string,
-                }),
-                prefabKey: t.type({
-                    m_defined: t.boolean,
-                    m_value: t.string,
-                }),
-                attributes: exports.EnemyAttributesIO,
-                lifePointReduce: t.type({
-                    m_defined: t.boolean,
-                    m_value: t.number,
-                }),
-                levelType: t.type({
-                    m_defined: t.boolean,
-                    m_value: t.number,
-                }),
-                rangeRadius: t.type({
-                    m_defined: t.boolean,
-                    m_value: t.number,
-                }),
-                numOfExtraDrops: t.type({
-                    m_defined: t.boolean,
-                    m_value: t.number,
-                }),
-                talentBlackboard: t.array(exports.BlackboardIO),
-                skills: t.array(exports.EnemySkillsIO),
-                spData: exports.EnemySpDataIO,
-            }),
+            enemyData: exports.EnemyData,
         })),
     }),
 });
@@ -570,22 +487,22 @@ exports.GameEventIO = t.type({
     rewardEndTime: t.number,
     displayOnHome: t.boolean,
     hasStage: t.boolean,
-    templateShopId: t.string,
-    medalGroupId: t.string,
+    templateShopId: t.union([t.string, t.null]),
+    medalGroupId: t.union([t.string, t.null]),
     isReplicate: t.boolean,
 });
 exports.ItemIO = t.type({
     data: t.type({
         itemId: t.string,
         name: t.string,
-        description: t.string,
-        rarity: t.number,
+        description: t.union([t.string, t.null]),
+        rarity: t.string,
         iconId: t.string,
         overrideBkg: t.null,
-        stackIconId: t.string,
+        stackIconId: t.union([t.string, t.null]),
         sortId: t.number,
-        usage: t.string,
-        obtainApproach: t.string,
+        usage: t.union([t.string, t.null]),
+        obtainApproach: t.union([t.string, t.null]),
         classifyType: t.string,
         itemType: t.string,
         stageDropList: t.array(t.type({
@@ -597,7 +514,7 @@ exports.ItemIO = t.type({
             formulaId: t.string,
         })),
     }),
-    formula: t.union([exports.ManufactFormulaIO, exports.WorkshopFormulaIO]),
+    formula: t.union([exports.ManufactFormulaIO, exports.WorkshopFormulaIO, t.null]),
 });
 exports.ModuleIO = t.type({
     info: t.type({
@@ -607,58 +524,67 @@ exports.ModuleIO = t.type({
         uniEquipDesc: t.string,
         typeIcon: t.string,
         typeName1: t.string,
-        typeName2: t.string,
+        typeName2: t.union([t.string, t.null]),
         equipShiningColor: t.string,
-        showEvolvePhase: t.number,
-        unlockEvolvePhase: t.number,
+        showEvolvePhase: t.string,
+        unlockEvolvePhase: t.string,
         charId: t.string,
-        tmplId: t.string,
+        tmplId: t.union([t.string, t.null]),
         showLevel: t.number,
         unlockLevel: t.number,
         unlockFavorPoint: t.number,
         missionList: t.array(t.string),
-        itemCost: t.record(t.string, t.array(exports.LevelUpCostIO)),
+        itemCost: t.union([t.record(t.string, t.array(exports.LevelUpCostIO)), t.null]),
         type: t.string,
         uniEquipGetTime: t.number,
         charEquipOrder: t.number,
     }),
-    data: t.type({
-        phases: t.array(t.type({
-            equipLevel: t.number,
-            parts: t.array(t.type({
-                resKey: t.string,
-                target: t.string,
-                isToken: t.boolean,
-                addOrOverrideTalentDataBundle: t.type({
-                    candidates: t.array(t.type({
-                        displayRangeId: t.boolean,
-                        upgradeDescription: t.string,
-                        talentIndex: t.number,
-                        unlockCondition: exports.OperatorUnlockCondIO,
-                        requiredPotentialRank: t.number,
-                        prefabKey: t.string,
-                        name: t.string,
-                        description: t.string,
-                        rangeId: t.string,
-                        blackboard: t.array(exports.BlackboardIO),
-                    })),
-                }),
-                overrideTraitDataBundle: t.type({
-                    candidates: t.array(t.type({
-                        additionalDescription: t.string,
-                        unlockCondition: exports.OperatorUnlockCondIO,
-                        requiredPotentialRank: t.number,
-                        blackboard: t.array(exports.BlackboardIO),
-                        overrideDescripton: t.string,
-                        prefabKey: t.string,
-                        rangeId: t.string,
-                    })),
-                }),
+    data: t.union([
+        t.type({
+            phases: t.array(t.type({
+                equipLevel: t.number,
+                parts: t.array(t.type({
+                    resKey: t.union([t.string, t.null]),
+                    target: t.string,
+                    isToken: t.boolean,
+                    addOrOverrideTalentDataBundle: t.type({
+                        candidates: t.union([
+                            t.array(t.type({
+                                displayRangeId: t.boolean,
+                                upgradeDescription: t.string,
+                                talentIndex: t.number,
+                                unlockCondition: exports.OperatorUnlockCondIO,
+                                requiredPotentialRank: t.number,
+                                prefabKey: t.string,
+                                name: t.union([t.string, t.null]),
+                                description: t.union([t.string, t.null]),
+                                rangeId: t.union([t.string, t.null]),
+                                blackboard: t.array(exports.BlackboardIO),
+                            })),
+                            t.null
+                        ]),
+                    }),
+                    overrideTraitDataBundle: t.type({
+                        candidates: t.union([
+                            t.array(t.type({
+                                additionalDescription: t.union([t.string, t.null]),
+                                unlockCondition: exports.OperatorUnlockCondIO,
+                                requiredPotentialRank: t.number,
+                                blackboard: t.array(exports.BlackboardIO),
+                                overrideDescripton: t.union([t.string, t.null]),
+                                prefabKey: t.union([t.string, t.null]),
+                                rangeId: t.union([t.string, t.null]),
+                            })),
+                            t.null
+                        ]),
+                    }),
+                })),
+                attributeBlackboard: t.array(exports.BlackboardIO),
+                tokenAttributeBlackboard: t.record(t.string, t.array(exports.BlackboardIO)),
             })),
-            attributeBlackboard: t.array(exports.BlackboardIO),
-            tokenAttributeBlackboard: t.record(t.string, t.array(exports.BlackboardIO)),
-        })),
-    }),
+        }),
+        t.null
+    ]),
 });
 exports.ParadoxIO = t.type({
     excel: t.type({
@@ -671,7 +597,7 @@ exports.ParadoxIO = t.type({
         loadingPicId: t.string,
         description: t.string,
         unlockParam: t.array(t.type({
-            unlockType: t.number,
+            unlockType: t.string,
             unlockParam1: t.string,
             unlockParam2: t.string,
             unlockParam3: t.null,
@@ -700,23 +626,23 @@ exports.SandboxActIO = t.type({
 });
 exports.SkillIO = t.type({
     skillId: t.string,
-    iconId: t.string,
+    iconId: t.union([t.string, t.null]),
     hidden: t.boolean,
     levels: t.array(t.type({
         name: t.string,
-        rangeId: t.string,
-        description: t.string,
+        rangeId: t.union([t.string, t.null]),
+        description: t.union([t.string, t.null]),
         skillType: t.string,
-        durationType: t.number,
+        durationType: t.string,
         spData: t.type({
-            spType: t.string,
+            spType: t.union([t.string, t.number]),
             levelUpCost: t.null,
             maxChargeTime: t.number,
             spCost: t.number,
             initSp: t.number,
             increment: t.number,
         }),
-        prefabId: t.string,
+        prefabId: t.union([t.string, t.null]),
         duration: t.number,
         blackboard: t.array(exports.BlackboardIO),
     })),
@@ -724,41 +650,43 @@ exports.SkillIO = t.type({
 exports.SkinIO = t.type({
     skinId: t.string,
     charId: t.string,
-    tokenSkinMap: t.array(t.type({
-        tokenId: t.string,
-        tokenSkinId: t.string,
-    })),
-    illustId: t.string,
-    dynIllustId: t.string,
+    tokenSkinMap: t.union([
+        t.array(t.type({
+            tokenId: t.string,
+            tokenSkinId: t.string,
+        })),
+        t.null
+    ]),
+    illustId: t.union([t.string, t.null]),
+    dynIllustId: t.union([t.string, t.null]),
     avatarId: t.string,
-    portraitId: t.string,
-    dynPortraitId: t.string,
-    dynEntranceId: t.string,
-    buildingId: t.string,
+    portraitId: t.union([t.string, t.null]),
+    dynPortraitId: t.union([t.string, t.null]),
+    dynEntranceId: t.union([t.string, t.null]),
+    buildingId: t.union([t.string, t.null]),
     battleSkin: t.type({
         overwritePrefab: t.boolean,
-        skinOrPrefabId: t.string,
+        skinOrPrefabId: t.union([t.string, t.null]),
     }),
     isBuySkin: t.boolean,
-    tmplId: t.string,
-    voiceId: t.string,
+    tmplId: t.union([t.string, t.null]),
+    voiceId: t.union([t.string, t.null]),
     voiceType: t.string,
     displaySkin: t.type({
-        skinName: t.string,
-        colorList: t.tuple([t.string, t.string, t.string, t.string, t.string]),
-        titleList: t.tuple([t.string, t.string]),
-        modelName: t.string,
-        drawerList: t.array(t.string),
-        skinGroupId: t.string,
-        skinGroupName: t.string,
+        skinName: t.union([t.string, t.null]),
+        colorList: t.union([t.tuple([t.string, t.string, t.string, t.string, t.string]), t.null]),
+        modelName: t.union([t.string, t.null]),
+        drawerList: t.union([t.array(t.string), t.null]),
+        skinGroupId: t.union([t.string, t.null]),
+        skinGroupName: t.union([t.string, t.null]),
         skinGroupSortIndex: t.number,
-        content: t.string,
-        dialog: t.string,
-        usage: t.string,
-        description: t.string,
-        obtainApproach: t.string,
+        content: t.union([t.string, t.null]),
+        dialog: t.union([t.string, t.null]),
+        usage: t.union([t.string, t.null]),
+        description: t.union([t.string, t.null]),
+        obtainApproach: t.union([t.string, t.null]),
         sortId: t.number,
-        displayTagId: t.string,
+        displayTagId: t.union([t.string, t.null]),
         getTime: t.number,
         onYear: t.number,
         onPeriod: t.number,
@@ -770,28 +698,31 @@ exports.StageIO = t.type({
         difficulty: t.string,
         performanceStageFlag: t.string,
         diffGroup: t.string,
-        unlockCondition: t.array(t.type({
-            stageId: t.string,
-            completeState: t.number,
-        })),
+        unlockCondition: t.array(t.union([
+            t.type({
+                stageId: t.string,
+                completeState: t.string,
+            }),
+            t.null
+        ])),
         stageId: t.string,
         levelId: t.string,
         zoneId: t.string,
         code: t.string,
         name: t.string,
         description: t.string,
-        hardStagedId: t.string,
-        dangerLevel: t.string,
+        hardStagedId: t.union([t.string, t.null]),
+        dangerLevel: t.union([t.string, t.null]),
         dangerPoint: t.number,
         loadingPicId: t.string,
         canPractice: t.boolean,
         canBattleReplay: t.boolean,
         apCost: t.number,
         apFailReturn: t.number,
-        etItemId: t.string,
+        etItemId: t.union([t.string, t.null]),
         etCost: t.number,
         etFailReturn: t.number,
-        etButtonStyle: t.string,
+        etButtonStyle: t.union([t.string, t.null]),
         apProtectTimes: t.number,
         diamondOnceDrop: t.number,
         practiceTicketCost: t.number,
@@ -803,14 +734,14 @@ exports.StageIO = t.type({
         passFavor: t.number,
         completeFavor: t.number,
         slProgress: t.number,
-        displayMainItem: t.string,
+        displayMainItem: t.union([t.string, t.null]),
         hilightMark: t.boolean,
         bossMark: t.boolean,
         isPredefined: t.boolean,
         isHardPredefined: t.boolean,
         isSkillSelectablePredefined: t.boolean,
         isStoryOnly: t.boolean,
-        appearanceStyle: t.number,
+        appearanceStyle: t.string,
         stageDropInfo: t.type({
             firstPassRewards: t.null,
             firstCompleteRewards: t.null,
@@ -822,15 +753,42 @@ exports.StageIO = t.type({
                 dropType: t.string,
             })),
             displayDetailRewards: t.array(t.type({
-                occPercent: t.number,
+                occPercent: t.string,
                 type: t.string,
                 id: t.string,
                 dropType: t.string,
             })),
         }),
-        startButtonOverrideId: t.string,
+        canUseCharm: t.boolean,
+        canUseTech: t.boolean,
+        canUseTrapTool: t.boolean,
+        canUseBattlePerformance: t.boolean,
+        startButtonOverrideId: t.union([t.string, t.null]),
         isStagePatch: t.boolean,
-        mainStageId: t.string,
+        mainStageId: t.union([t.string, t.null]),
+        extraCondition: t.union([
+            t.array(t.type({
+                index: t.number,
+                template: t.string,
+                unlockParam: t.array(t.string),
+            })),
+            t.null
+        ]),
+        extraInfo: t.union([
+            t.array(t.type({
+                stageId: t.string,
+                rewards: t.array(t.type({
+                    id: t.string,
+                    count: t.number,
+                    type: t.string,
+                })),
+                progressInfo: t.type({
+                    progressType: t.string,
+                    descList: t.record(t.string, t.string),
+                })
+            })),
+            t.null
+        ])
     }),
     levels: exports.StageDataIO,
 });
@@ -849,89 +807,98 @@ exports.OperatorIO = t.type({
         }),
         skill: exports.BaseIO,
     })),
-    paradox: exports.ParadoxIO,
+    paradox: t.union([exports.ParadoxIO, t.null]),
     data: t.type({
         name: t.string,
         description: t.string,
         canUseGeneralPotentialItem: t.boolean,
-        potentialItemId: t.string,
-        nationId: t.string,
-        groupId: t.string,
-        teamId: t.string,
-        displayNumber: t.string,
-        tokenKey: t.string,
+        potentialItemId: t.union([t.string, t.null]),
+        nationId: t.union([t.string, t.null]),
+        groupId: t.union([t.string, t.null]),
+        teamId: t.union([t.string, t.null]),
+        displayNumber: t.union([t.string, t.null]),
+        // tokenKey: t.string,
         appellation: t.string,
         position: t.string,
         tagList: t.array(t.string),
-        itemUsage: t.string,
-        itemDesc: t.string,
-        itemObtainApproach: t.string,
+        itemUsage: t.union([t.string, t.null]),
+        itemDesc: t.union([t.string, t.null]),
+        itemObtainApproach: t.union([t.string, t.null]),
         isNotObtainable: t.boolean,
         isSpChar: t.boolean,
         maxPotentialLevel: t.number,
         rarity: t.string,
         profession: t.string,
         subProfessionId: t.string,
-        trait: t.type({
-            candidates: t.array(t.type({
-                unlockCondition: exports.OperatorUnlockCondIO,
-                requiredPotentialRank: t.number,
-                blackboard: t.array(exports.BlackboardIO),
-                overrideDescripton: t.string,
-                prefabKey: t.string,
-                rangeId: t.string,
-            })),
-        }),
+        trait: t.union([
+            t.type({
+                candidates: t.array(t.type({
+                    unlockCondition: exports.OperatorUnlockCondIO,
+                    requiredPotentialRank: t.number,
+                    blackboard: t.array(exports.BlackboardIO),
+                    overrideDescripton: t.union([t.string, t.null]),
+                    prefabKey: t.union([t.string, t.null]),
+                    rangeId: t.union([t.string, t.null]),
+                })),
+            }),
+            t.null
+        ]),
         phases: t.array(t.type({
             characterPrefabKey: t.string,
             rangeId: t.string,
             maxLevel: t.number,
             attributesKeyFrames: t.array(exports.AttributesKeyFrameIO),
-            evolveCost: t.array(exports.LevelUpCostIO),
+            evolveCost: t.union([t.array(exports.LevelUpCostIO), t.null]),
         })),
         skills: t.array(t.type({
             skillId: t.string,
-            overridePrefabKey: t.string,
-            overrideTokenKey: t.string,
+            overridePrefabKey: t.union([t.string, t.null]),
+            overrideTokenKey: t.union([t.string, t.null]),
             levelUpCostCond: t.array(exports.LevelUpCostCondIO),
             unlockCond: exports.OperatorUnlockCondIO,
         })),
-        talents: t.array(t.type({
-            candidates: t.array(t.type({
-                unlockCondition: exports.OperatorUnlockCondIO,
-                requiredPotentialRank: t.number,
-                prefabKey: t.string,
-                name: t.string,
-                description: t.string,
-                rangeId: t.string,
-                blackboard: t.array(exports.BlackboardIO),
+        talents: t.union([
+            t.array(t.type({
+                candidates: t.array(t.type({
+                    unlockCondition: exports.OperatorUnlockCondIO,
+                    requiredPotentialRank: t.number,
+                    prefabKey: t.string,
+                    name: t.string,
+                    description: t.string,
+                    rangeId: t.union([t.string, t.null]),
+                    blackboard: t.array(exports.BlackboardIO),
+                })),
             })),
-        })),
+            t.null
+        ]),
         potentialRanks: t.array(t.type({
-            type: t.number,
+            type: t.string,
             description: t.string,
-            buff: t.type({
-                attributes: t.type({
-                    abnormalFlags: t.null,
-                    abnormalImmunes: t.null,
-                    abnormalAntis: t.null,
-                    abnormalCombos: t.null,
-                    abnormalComboImmunes: t.null,
-                    attributeModifiers: t.array(t.type({
-                        attributeType: t.number,
-                        formulaItem: t.number,
-                        value: t.number,
-                        loadFromBlackboard: t.boolean,
-                        fetchBaseValueFromSourceEntity: t.boolean,
-                    })),
+            buff: t.union([
+                t.type({
+                    attributes: t.type({
+                        abnormalFlags: t.null,
+                        abnormalImmunes: t.null,
+                        abnormalAntis: t.null,
+                        abnormalCombos: t.null,
+                        abnormalComboImmunes: t.null,
+                        attributeModifiers: t.array(t.type({
+                            attributeType: t.string,
+                            formulaItem: t.string,
+                            value: t.number,
+                            loadFromBlackboard: t.boolean,
+                            fetchBaseValueFromSourceEntity: t.boolean,
+                        })),
+                    }),
                 }),
-            }),
+                t.null
+            ]),
             equivalentCost: t.null,
         })),
         favorKeyFrames: t.array(exports.AttributesKeyFrameIO),
         allSkillLvlup: t.array(t.type({
             unlockCond: exports.OperatorUnlockCondIO,
-            lvlUpCost: t.array(exports.LevelUpCostIO),
+            lvlUpCost: t.union([t.array(exports.LevelUpCostIO), t.null]),
         })),
     }),
 });