import EventEmitter from 'events';
import fs from 'fs';
import * as cheerio from 'cheerio';
import { z } from 'zod';

type AnimalCodexExcelConfigDataType = {
    EJNDNFFKDHN: number[];
    countType: CountType;
    describeId: number;
    descTextMapHash: number;
    id: number;
    IEDNJFPPPHD: number[];
    DGPFHOOEKNC: number;
    isDisuse: boolean;
    isSeenActive: boolean;
    modelPath: string;
    KOGKIGNPAIO: number[];
    AJPLBCNANHO: number;
    pushTipsCodexId: number;
    showOnlyUnlocked: boolean;
    sortOrder: number;
    subType: SubType;
    type: Type$7;
};
declare enum CountType {
    CodexCountTypeCapture = "CODEX_COUNT_TYPE_CAPTURE",
    CodexCountTypeFish = "CODEX_COUNT_TYPE_FISH",
    CodexCountTypeKill = "CODEX_COUNT_TYPE_KILL",
    CodexCountTypeNone = "CODEX_COUNT_TYPE_NONE"
}
declare enum SubType {
    CodexSubtypeAbyss = "CODEX_SUBTYPE_ABYSS",
    CodexSubtypeAnimal = "CODEX_SUBTYPE_ANIMAL",
    CodexSubtypeAutomatron = "CODEX_SUBTYPE_AUTOMATRON",
    CodexSubtypeAviary = "CODEX_SUBTYPE_AVIARY",
    CodexSubtypeBeast = "CODEX_SUBTYPE_BEAST",
    CodexSubtypeBoss = "CODEX_SUBTYPE_BOSS",
    CodexSubtypeCritter = "CODEX_SUBTYPE_CRITTER",
    CodexSubtypeElemental = "CODEX_SUBTYPE_ELEMENTAL",
    CodexSubtypeFatui = "CODEX_SUBTYPE_FATUI",
    CodexSubtypeFish = "CODEX_SUBTYPE_FISH",
    CodexSubtypeHilichurl = "CODEX_SUBTYPE_HILICHURL",
    CodexSubtypeHuman = "CODEX_SUBTYPE_HUMAN"
}
declare enum Type$7 {
    CodexAnimal = "CODEX_ANIMAL",
    CodexMonster = "CODEX_MONSTER"
}

type AvatarCostumeExcelConfigDataType = {
    animatorConfigPathHash: number;
    characterId: number;
    controllerPathHash: number;
    controllerRemotePathHash: number;
    HINKMCLODHL: number;
    descTextMapHash: number;
    hide: boolean;
    frontIconName: string;
    NFLEEEMIDDO: number;
    isDefault: boolean;
    JKGJCFBBGNJ: boolean;
    KPBMFEFNLBC: boolean;
    imageNameHash: number;
    indexID: number;
    PEEEMKCPLLB: boolean;
    itemId: number;
    jsonName: string;
    KGAFLJJDGFI: number;
    KJNEBKBDNJI: number;
    NGNIMLHLGMF: number;
    nameTextMapHash: number;
    prefabManekinPathHash: number;
    prefabNpcPathHash: number;
    prefabPathHash: number;
    prefabRemotePathHash: number;
    quality: number;
    sideIconName: string;
    skinId: number;
};

type AvatarCurveExcelConfigDataType = {
    curveInfos: CurveInfo$2[];
    level: number;
};
type CurveInfo$2 = {
    arith: Arith$2;
    type: Type$6;
    value: number;
};
declare enum Arith$2 {
    ArithMulti = "ARITH_MULTI"
}
declare enum Type$6 {
    GrowCurveAttackS4 = "GROW_CURVE_ATTACK_S4",
    GrowCurveAttackS5 = "GROW_CURVE_ATTACK_S5",
    GrowCurveHPS4 = "GROW_CURVE_HP_S4",
    GrowCurveHPS5 = "GROW_CURVE_HP_S5"
}

type AvatarExcelConfigDataType = {
    BDKICGKLCMA: number;
    campID: number;
    CIAPMJAEIHD: number;
    animatorConfigPathHash: number;
    attackBase: number;
    avatarIdentityType: AvatarIdentityType;
    avatarPromoteId: number;
    avatarPromoteRewardIdList: number[];
    avatarPromoteRewardLevelList: number[];
    EFBDEAEJMNJ: number;
    elecSubHurt: number;
    EPBCFFKHAIM: Epbcffkhaim;
    bodyType: BodyType;
    elementMastery: number;
    KBGIKODHDPA: Epbcffkhaim;
    fireSubHurt: number;
    candSkillDepotIds: number[];
    GPHICMPCPFA: number;
    chargeEfficiency: number;
    combatConfigHash: number;
    controllerPathHash: number;
    controllerPathRemoteHash: number;
    coopPicNameHash: number;
    critical: number;
    criticalHurt: number;
    defenseBase: number;
    deformationMeshPathHash: number;
    CMHFEAFOLPG: number;
    grassSubHurt: number;
    HCHFHPEKGHO: number;
    HDJEMKFONAD: number;
    HGJCAPNOMAA: number;
    iceSubHurt: number;
    featureTagGroupID: number;
    MAEJJKELOBK: number;
    IFNGBLPHINC: number;
    gachaCardNameHash: number;
    gachaImageNameHash: number;
    IJIPDMJLGNB: number;
    ILDGFINBLII: number;
    IOMANLCNFEO: number;
    LLPAFFFGFBP: number;
    hpBase: number;
    JEOILPDPBCF: number;
    iconName: string;
    id: number;
    KGOGCJLGLNI: number;
    imageName: string;
    initialWeapon: number;
    CDBLKEGMAEN: boolean;
    HINKMCLODHL: number;
    NCLJNCFOILK: number;
    NKGIPKIAOGH: number;
    NOCDAKPNGFO: number;
    lodPatternName: string;
    GDACAJPIPCJ: boolean;
    manekinJsonConfigHash: number;
    manekinMotionConfig: number;
    manekinPathHash: number;
    MOCNCNMLBHE: string;
    descTextMapHash: number;
    PBJALANPDBD: number;
    nameTextMapHash: number;
    PDKIEBDGBCC: Epbcffkhaim;
    isRangeAttack: boolean;
    physicalSubHurt: number;
    POKAEPFKOLI: number;
    prefabPathHash: number;
    prefabPathRagdollHash: number;
    prefabPathRemoteHash: number;
    propGrowCurves: PropGrowCurve$1[];
    qualityType: QualityType;
    rockSubHurt: number;
    scriptDataPathHash: number;
    sideIconName: string;
    skillDepotId: number;
    specialDeformationMeshPathHash: number;
    staminaRecoverSpeed: number;
    tags: Tag[];
    useType: UseType;
    waterSubHurt: number;
    weaponType: WeaponType$1;
    windSubHurt: number;
};
declare enum Epbcffkhaim {
    FightPropAttackPercent = "FIGHT_PROP_ATTACK_PERCENT",
    FightPropChargeEfficiency = "FIGHT_PROP_CHARGE_EFFICIENCY",
    FightPropCritical = "FIGHT_PROP_CRITICAL",
    FightPropCriticalHurt = "FIGHT_PROP_CRITICAL_HURT",
    FightPropDefensePercent = "FIGHT_PROP_DEFENSE_PERCENT",
    FightPropElementMastery = "FIGHT_PROP_ELEMENT_MASTERY",
    FightPropHPPercent = "FIGHT_PROP_HP_PERCENT",
    FightPropNone = "FIGHT_PROP_NONE",
    FightPropPhysicalAddHurt = "FIGHT_PROP_PHYSICAL_ADD_HURT"
}
declare enum AvatarIdentityType {
    AvatarIdentityMaster = "AVATAR_IDENTITY_MASTER",
    AvatarIdentityNormal = "AVATAR_IDENTITY_NORMAL"
}
declare enum BodyType {
    BodyBoy = "BODY_BOY",
    BodyGirl = "BODY_GIRL",
    BodyLady = "BODY_LADY",
    BodyLoli = "BODY_LOLI",
    BodyMale = "BODY_MALE"
}
type PropGrowCurve$1 = {
    growCurve: GrowCurve$1;
    type: Type$5;
};
declare enum GrowCurve$1 {
    GrowCurveAttackS4 = "GROW_CURVE_ATTACK_S4",
    GrowCurveAttackS5 = "GROW_CURVE_ATTACK_S5",
    GrowCurveHPS4 = "GROW_CURVE_HP_S4",
    GrowCurveHPS5 = "GROW_CURVE_HP_S5"
}
declare enum Type$5 {
    FightPropBaseAttack = "FIGHT_PROP_BASE_ATTACK",
    FightPropBaseDefense = "FIGHT_PROP_BASE_DEFENSE",
    FightPropBaseHP = "FIGHT_PROP_BASE_HP"
}
declare enum QualityType {
    QualityOrange = "QUALITY_ORANGE",
    QualityOrangeSP = "QUALITY_ORANGE_SP",
    QualityPurple = "QUALITY_PURPLE"
}
declare enum Tag {
    AvatarTagHexenzirkel = "AVATAR_TAG_HEXENZIRKEL",
    AvatarTagMoonphase = "AVATAR_TAG_MOONPHASE",
    None = "None"
}
declare enum UseType {
    AvatarAbandon = "AVATAR_ABANDON",
    AvatarFormal = "AVATAR_FORMAL",
    AvatarSyncTest = "AVATAR_SYNC_TEST",
    AvatarTest = "AVATAR_TEST"
}
declare enum WeaponType$1 {
    WeaponBow = "WEAPON_BOW",
    WeaponCatalyst = "WEAPON_CATALYST",
    WeaponClaymore = "WEAPON_CLAYMORE",
    WeaponPole = "WEAPON_POLE",
    WeaponSwordOneHand = "WEAPON_SWORD_ONE_HAND"
}

type AvatarPromoteExcelConfigDataType = {
    addProps: AddProp$5[];
    avatarPromoteId: number;
    costItems: CostItem$2[];
    promoteAudio: string;
    promoteLevel: number;
    requiredPlayerLevel: number;
    scoinCost: number;
    unlockMaxLevel: number;
};
type AddProp$5 = {
    propType: PropType$6;
    value: number;
};
declare enum PropType$6 {
    FightPropAttackPercent = "FIGHT_PROP_ATTACK_PERCENT",
    FightPropBaseAttack = "FIGHT_PROP_BASE_ATTACK",
    FightPropBaseDefense = "FIGHT_PROP_BASE_DEFENSE",
    FightPropBaseHP = "FIGHT_PROP_BASE_HP",
    FightPropChargeEfficiency = "FIGHT_PROP_CHARGE_EFFICIENCY",
    FightPropCritical = "FIGHT_PROP_CRITICAL",
    FightPropCriticalHurt = "FIGHT_PROP_CRITICAL_HURT",
    FightPropDefensePercent = "FIGHT_PROP_DEFENSE_PERCENT",
    FightPropElecAddHurt = "FIGHT_PROP_ELEC_ADD_HURT",
    FightPropElementMastery = "FIGHT_PROP_ELEMENT_MASTERY",
    FightPropFireAddHurt = "FIGHT_PROP_FIRE_ADD_HURT",
    FightPropGrassAddHurt = "FIGHT_PROP_GRASS_ADD_HURT",
    FightPropHPPercent = "FIGHT_PROP_HP_PERCENT",
    FightPropHealAdd = "FIGHT_PROP_HEAL_ADD",
    FightPropIceAddHurt = "FIGHT_PROP_ICE_ADD_HURT",
    FightPropPhysicalAddHurt = "FIGHT_PROP_PHYSICAL_ADD_HURT",
    FightPropRockAddHurt = "FIGHT_PROP_ROCK_ADD_HURT",
    FightPropWaterAddHurt = "FIGHT_PROP_WATER_ADD_HURT",
    FightPropWindAddHurt = "FIGHT_PROP_WIND_ADD_HURT"
}
type CostItem$2 = {
    count: number;
    id: number;
};

type AvatarSkillDepotExcelConfigDataType = {
    attackModeSkill: number;
    energySkill: number;
    extraAbilities: string[];
    inherentProudSkillOpens: InherentProudSkillOpen[];
    BDKHFEFKECB: number;
    id: number;
    JGJCJEEOFCK: number;
    PPMJAMDEFFO: Ppmjamdeffo$1;
    leaderTalent: number;
    LLALJAIDKPI: Llaljaidkpi[];
    JNBEFHILAIP: number;
    skillDepotAbilityGroup: string;
    skills: number[];
    subSkills: number[];
    talents: number[];
    talentStarName: string;
};
type Llaljaidkpi = {
    AFMEMNMEABG: number[];
    KLHCAFHKLNI: Klhcafhklni;
    proudSkillGroupId: number;
};
declare enum Klhcafhklni {
    SpecialProudSkillOpenConditionTypeNone = "SPECIAL_PROUD_SKILL_OPEN_CONDITION_TYPE_NONE",
    SpecialProudSkillOpenConditionTypeQuestFinish = "SPECIAL_PROUD_SKILL_OPEN_CONDITION_TYPE_QUEST_FINISH"
}
declare enum Ppmjamdeffo$1 {
    Furina = "Furina",
    None = "None",
    Ousia = "Ousia",
    Pneuma = "Pneuma"
}
type InherentProudSkillOpen = {
    needAvatarPromoteLevel: number;
    proudSkillGroupId: number;
};

type AvatarSkillExcelConfigDataType = {
    abilityName: string;
    BGINCKANIGF: boolean;
    buffIcon: BuffIcon;
    cdSlot: number;
    cdTime: number;
    CGJLEIHOKLN: Cgjleihokln;
    costElemType: CostElemType;
    costElemVal: number;
    costStamina: number;
    DAHEPAIKAJE: boolean;
    DEAEBMEIFLO: Deaebmeiflo;
    descTextMapHash: number;
    dragType: DragType;
    EFHHGFKPGJO: boolean;
    energyMin: number;
    extraDescTextMapHash: number;
    FOJNHEKGGCB: boolean;
    GLGOMNEPNDH: boolean;
    globalValueKey: GlobalValueKey;
    HOBKGMMNHLI: boolean;
    IACNAENANDH: number;
    id: number;
    isAttackCameraLock: boolean;
    LGHAEDLLNFF: number;
    LLINBJLCONJ: boolean;
    lockShape: LockShape;
    lockWeightParams: number[];
    maxChargeNum: number;
    MHLANHFCMBJ: boolean;
    MIFFDPCHFID: boolean;
    nameTextMapHash: number;
    needMonitor: NeedMonitor;
    OKLOMDDKDMJ: boolean;
    PHBLMBKDEOG: number;
    proudSkillGroupId: number;
    shareCDID: number;
    skillIcon: string;
    triggerID: number;
};
declare enum Cgjleihokln {
    DurinBlack = "DurinBlack",
    DurinWhite = "DurinWhite",
    None = "None"
}
declare enum Deaebmeiflo {
    SpecialEnergyMavuika = "SPECIAL_ENERGY_MAVUIKA",
    SpecialEnergyNone = "SPECIAL_ENERGY_NONE",
    SpecialEnergySkirk = "SPECIAL_ENERGY_SKIRK"
}
declare enum BuffIcon {
    Empty = "",
    SkillBBarbara01 = "Skill_B_Barbara_01"
}
declare enum CostElemType {
    Electric = "Electric",
    Fire = "Fire",
    Grass = "Grass",
    Ice = "Ice",
    None = "None",
    Rock = "Rock",
    Water = "Water",
    Wind = "Wind"
}
declare enum DragType {
    DragNone = "DRAG_NONE",
    DragRotateCamera = "DRAG_ROTATE_CAMERA",
    DragRotateCharacter = "DRAG_ROTATE_CHARACTER"
}
declare enum GlobalValueKey {
    AVATARMagnetAbsorbSkill = "AVATAR_MagnetAbsorbSkill",
    AVATARMagnetThrowSkill = "AVATAR_MagnetThrowSkill",
    AVATARSelectLauncherTargetCharge = "AVATAR_Select_Launcher_Target_Charge",
    Avatar6_0_QuestEnergy = "AVATAR_6_0_QUEST_ENERGY",
    AvatarBlockingEnergy = "AVATAR_BLOCKING_ENERGY",
    AvatarBlockingMikawaflowerEnergy = "AVATAR_BLOCKING_MIKAWAFLOWER_ENERGY",
    AvatarBreakoutEnergy = "AVATAR_BREAKOUT_ENERGY",
    AvatarDiveEnergy = "AVATAR_DIVE_ENERGY",
    AvatarGlidingEnergy = "AVATAR_GLIDING_ENERGY",
    AvatarInazumaBadmintonHuge = "AVATAR_INAZUMA_BADMINTON_HUGE",
    AvatarLanv3RaceEnergy = "AVATAR_LANV3RACE_ENERGY",
    AvatarMvmEnergy = "AVATAR_MVM_ENERGY",
    AvatarSeekandhideEnergy = "AVATAR_SEEKANDHIDE_ENERGY",
    Empty = "",
    FlyingSquirrelFlyEnergy = "Flying_Squirrel_FlyEnergy",
    GVHoldBallFlag = "GV_HoldBallFlag",
    GVV61_QuestRerirFightNeferSpecialEnergy = "GV_V6_1_Quest_Rerir_Fight_NeferSpecialEnergy",
    OrigamiSquirrelReturnEnergy = "OrigamiSquirrel_Return_Energy",
    TeamAntiKillEnergy = "TEAM_ANTI_KILL_ENERGY"
}
declare enum LockShape {
    CircleLockEnemy = "CircleLockEnemy",
    CircleLockEnemyAmborFly = "CircleLockEnemyAmborFly",
    CircleLockEnemyR10 = "CircleLockEnemyR10",
    CircleLockEnemyR10H6HC = "CircleLockEnemyR10H6HC",
    CircleLockEnemyR12H14HC = "CircleLockEnemyR12H14HC",
    CircleLockEnemyR15H10HC = "CircleLockEnemyR15H10HC",
    CircleLockEnemyR25H10HC = "CircleLockEnemyR25H10HC",
    CircleLockEnemyR5H10HC = "CircleLockEnemyR5H10HC",
    CircleLockEnemyR5H6HC = "CircleLockEnemyR5H6HC",
    CircleLockEnemyR7H6HC = "CircleLockEnemyR7H6HC",
    CircleLockEnemyR8H6HC = "CircleLockEnemyR8H6HC",
    CircleR25H20HC = "CircleR25H20HC"
}
declare enum NeedMonitor {
    MonitorNever = "MONITOR_NEVER",
    MonitorOffStage = "MONITOR_OFF_STAGE",
    MonitorOnStage = "MONITOR_ON_STAGE"
}

type AvatarTalentExcelConfigDataType = {
    addProps: AddProp$4[];
    descTextMapHash: number;
    EEADMPJDKLA: number;
    IACNAENANDH: number;
    icon: string;
    mainCostItemCount: number;
    mainCostItemId: number;
    nameTextMapHash: number;
    openConfig: string;
    paramList: number[];
    MLPEJMIJALL: number;
    prevTalent: number;
    talentId: number;
};
type AddProp$4 = {
    propType: PropType$5;
    value: number;
};
declare enum PropType$5 {
    FightPropChargeEfficiency = "FIGHT_PROP_CHARGE_EFFICIENCY",
    FightPropNone = "FIGHT_PROP_NONE"
}

type DungeonEntryExcelConfigDataType = {
    GAAIKDHGIAI: boolean;
    condComb: CondComb;
    cooldownTipsDungeonId: number[];
    descriptionCycleRewardList: Array<number[]>;
    descTextMapHash: number;
    dungeonEntryId: number;
    id: number;
    EMCEEGJKLMK: number;
    isDefaultOpen: boolean;
    isShowInAdvHandbook: boolean;
    GMPKHIHBPAD: number;
    MBNGDKJLBOP: number[];
    picPath: string;
    rewardDataId: number;
    satisfiedCond: SatisfiedCond[];
    sceneId: number;
    systemOpenUiId: number;
    type: string;
};
declare enum CondComb {
    LogicNone = "LOGIC_NONE",
    LogicOr = "LOGIC_OR"
}
type SatisfiedCond = {
    param1: number;
    param2: number;
    type: Type$4;
};
declare enum Type$4 {
    DungeonEntryConditionLevel = "DUNGEON_ENTRY_CONDITION_LEVEL",
    DungeonEntryConditionNone = "DUNGEON_ENTRY_CONDITION_NONE",
    DungeonEntryConditionQuest = "DUNGEON_ENTRY_CONDITION_QUEST"
}

type DungeonLevelEntityConfigDataType = {
    abilityGroupName: string;
    clientId: number;
    descTextMapHash: number;
    id: number;
    levelConfigName: string;
    OHICBGIFKGF: Ohicbgifkgf;
    show: boolean;
    switchTitleTextMapHash: number;
};
declare enum Ohicbgifkgf {
    ActivityAbilityLevelBuffTowerBuffFireNormalAttackUp = "ActivityAbility_LevelBuff_TowerBuff_FireNormalAttackUp",
    ActivityAbilityLevelBuffTowerBuffNyxAttackUp = "ActivityAbility_LevelBuff_TowerBuff_NyxAttackUp",
    Empty = "",
    LevelBuffTowerBuffElemReactSwirlUp = "LevelBuff_TowerBuff_ElemReactSwirlUp",
    LevelBuffTowerBuffFallATKDamageUp6_2 = "LevelBuff_TowerBuff_FallATKDamageUp_6_2",
    LevelBuffTowerBuffFallingAttackUp = "LevelBuff_TowerBuff_FallingAttackUp",
    LevelBuffTowerBuffFireDamageUp6_2 = "LevelBuff_TowerBuff_FireDamageUp_6_2",
    LevelBuffTowerBuffGrassElementalArtUp = "LevelBuff_TowerBuff_GrassElementalArtUp",
    LevelBuffTowerBuffIceDamageUp = "LevelBuff_TowerBuff_IceDamageUp",
    LevelBuffTowerBuffIceElementalArtUp = "LevelBuff_TowerBuff_IceElementalArtUp",
    LevelBuffTowerBuffIceExtraAttackUp = "LevelBuff_TowerBuff_IceExtraAttackUp",
    LevelBuffTowerBuffIceNormalAttackUp = "LevelBuff_TowerBuff_IceNormalAttackUp",
    LevelBuffTowerBuffNoneEnergyDamageUp = "LevelBuff_TowerBuff_NoneEnergyDamageUp",
    LevelBuffTowerBuffOvergrowDamageUp6_0 = "LevelBuff_TowerBuff_OvergrowDamageUp_6_0",
    LevelBuffTowerBuffRockElementalArtUp = "LevelBuff_TowerBuff_RockElementalArtUp",
    LevelBuffTowerBuffShockDamageUp = "LevelBuff_TowerBuff_ShockDamageUp",
    LevelBuffTowerBuffShockDamageUp6_0 = "LevelBuff_TowerBuff_ShockDamageUp_6_0",
    LevelBuffTowerBuffTestFor533 = "LevelBuff_TowerBuff_TestFor53_3",
    LevelBuffTowerBuffTestFor534 = "LevelBuff_TowerBuff_TestFor53_4",
    LevelBuffTowerBuffWaterElementalArtUp = "LevelBuff_TowerBuff_WaterElementalArtUp"
}

type EquipAffixExcelConfigDataType = {
    addProps: AddProp$3[];
    affixId: number;
    descTextMapHash: number;
    id: number;
    level: number;
    nameTextMapHash: number;
    openConfig: string;
    paramList: number[];
};
type AddProp$3 = {
    propType: PropType$4;
    value: number;
};
declare enum PropType$4 {
    FightPropAddHurt = "FIGHT_PROP_ADD_HURT",
    FightPropAttackPercent = "FIGHT_PROP_ATTACK_PERCENT",
    FightPropChargeEfficiency = "FIGHT_PROP_CHARGE_EFFICIENCY",
    FightPropCritical = "FIGHT_PROP_CRITICAL",
    FightPropCriticalHurt = "FIGHT_PROP_CRITICAL_HURT",
    FightPropDefense = "FIGHT_PROP_DEFENSE",
    FightPropDefensePercent = "FIGHT_PROP_DEFENSE_PERCENT",
    FightPropElecAddHurt = "FIGHT_PROP_ELEC_ADD_HURT",
    FightPropElecSubHurt = "FIGHT_PROP_ELEC_SUB_HURT",
    FightPropElementMastery = "FIGHT_PROP_ELEMENT_MASTERY",
    FightPropFireAddHurt = "FIGHT_PROP_FIRE_ADD_HURT",
    FightPropFireSubHurt = "FIGHT_PROP_FIRE_SUB_HURT",
    FightPropGrassAddHurt = "FIGHT_PROP_GRASS_ADD_HURT",
    FightPropHP = "FIGHT_PROP_HP",
    FightPropHPPercent = "FIGHT_PROP_HP_PERCENT",
    FightPropHealAdd = "FIGHT_PROP_HEAL_ADD",
    FightPropHealedAdd = "FIGHT_PROP_HEALED_ADD",
    FightPropIceAddHurt = "FIGHT_PROP_ICE_ADD_HURT",
    FightPropNone = "FIGHT_PROP_NONE",
    FightPropPhysicalAddHurt = "FIGHT_PROP_PHYSICAL_ADD_HURT",
    FightPropRockAddHurt = "FIGHT_PROP_ROCK_ADD_HURT",
    FightPropShieldCostMinusRatio = "FIGHT_PROP_SHIELD_COST_MINUS_RATIO",
    FightPropWaterAddHurt = "FIGHT_PROP_WATER_ADD_HURT",
    FightPropWindAddHurt = "FIGHT_PROP_WIND_ADD_HURT"
}

type FetterInfoExcelConfigDataType = {
    avatarAssocType: string;
    avatarConstellationAfterTextMapHash: number;
    avatarConstellationBeforTextMapHash: number;
    avatarDetailTextMapHash: number;
    avatarId: number;
    avatarNativeTextMapHash: number;
    avatarTitleTextMapHash: number;
    avatarVisionAfterTextMapHash: number;
    avatarVisionBeforTextMapHash: number;
    PKJJAOCGOPO: number;
    cvChineseTextMapHash: number;
    cvEnglishTextMapHash: number;
    cvJapaneseTextMapHash: number;
    cvKoreanTextMapHash: number;
    fetterId: number;
    finishConds: FinishCond[];
    infoBirthDay: number;
    infoBirthMonth: number;
    isHiden: boolean;
    PMDBPIJHHPC: number;
    openConds: any[];
};
type FinishCond = {
    condType: CondType$2;
    paramList: number[];
};
declare enum CondType$2 {
    FetterCondAvatarLevel = "FETTER_COND_AVATAR_LEVEL",
    FetterCondFinishQuest = "FETTER_COND_FINISH_QUEST",
    FetterCondNotOpen = "FETTER_COND_NOT_OPEN"
}

type FettersExcelConfigDataType = {
    avatarId: number;
    fetterId: number;
    finishConds: any[];
    hideCostumeList: number[];
    isHiden: boolean;
    openConds: OpenCond[];
    showCostumeList: number[];
    tips: number[];
    type: number;
    voiceFile: string;
    voiceFileTextTextMapHash: number;
    voiceTitleLockedTextMapHash: number;
    voiceTitleTextMapHash: number;
};
type OpenCond = {
    condType: CondType$1;
    paramList: number[];
};
declare enum CondType$1 {
    FetterCondAvatarPromoteLevel = "FETTER_COND_AVATAR_PROMOTE_LEVEL",
    FetterCondFetterLevel = "FETTER_COND_FETTER_LEVEL",
    FetterCondFinishParentQuest = "FETTER_COND_FINISH_PARENT_QUEST",
    FetterCondFinishQuest = "FETTER_COND_FINISH_QUEST",
    FetterCondNone = "FETTER_COND_NONE",
    FetterCondNotOpen = "FETTER_COND_NOT_OPEN",
    FetterCondPlayerBirthday = "FETTER_COND_PLAYER_BIRTHDAY",
    FetterCondUnlockTransPoint = "FETTER_COND_UNLOCK_TRANS_POINT"
}

type FetterStoryExcelConfigDataType = {
    avatarId: number;
    fetterId: number;
    finishConds: Cond$1[];
    isHiden: boolean;
    openConds: Cond$1[];
    storyContext2TextMapHash: number;
    storyContextTextMapHash: number;
    storyTitle2TextMapHash: number;
    storyTitleLockedTextMapHash: number;
    storyTitleTextMapHash: number;
    tips: number[];
};
type Cond$1 = {
    condType: CondType;
    paramList: number[];
};
declare enum CondType {
    FetterCondFetterLevel = "FETTER_COND_FETTER_LEVEL",
    FetterCondFinishParentQuest = "FETTER_COND_FINISH_PARENT_QUEST",
    FetterCondFinishQuest = "FETTER_COND_FINISH_QUEST",
    FetterCondNone = "FETTER_COND_NONE",
    FetterCondNotOpen = "FETTER_COND_NOT_OPEN"
}

type ManualTextMapConfigDataType = {
    paramTypes: ParamType[];
    textMapContentTextMapHash: number;
    textMapId: string;
};
declare enum ParamType {
    TextParamAvatarName = "TEXT_PARAM_AVATAR_NAME",
    TextParamNone = "TEXT_PARAM_NONE",
    TextParamRoutineType = "TEXT_PARAM_ROUTINE_TYPE"
}

type MaterialExcelConfigDataType = {
    closeBagAfterUsed: boolean;
    cdGroup: number;
    cdTime: number;
    dropable: boolean;
    descTextMapHash: number;
    destroyReturnMaterial: any[];
    destroyReturnMaterialCount: any[];
    destroyRule: DestroyRule$2;
    IOMEHCHLAJM: boolean;
    GOFEFCODPII: Gofefcodpii;
    isForceGetHint: boolean;
    effectDescTextMapHash: number;
    effectGadgetID: number;
    effectIcon: EffectIcon;
    effectName: EffectName;
    foodQuality: FoodQuality;
    gadgetId: number;
    globalItemLimit: number;
    icon: string;
    id: number;
    interactionTitleTextMapHash: number;
    isHidden: boolean;
    isSplitDrop: boolean;
    noFirstGetHint: boolean;
    itemType: ItemType$2;
    itemUse: ItemUse[];
    PCOPCNFOONA: Pcopcnfoona;
    materialType: MaterialType$1;
    maxUseCount: number;
    nameTextMapHash: number;
    PHKICCAOKCK: boolean;
    HJCEKDFGLCG: Hjcekdfglcg;
    picPath: string[];
    playGainEffect: boolean;
    rank: number;
    rankLevel: number;
    satiationParams: number[];
    setID: number;
    specialDescTextMapHash: number;
    stackLimit: number;
    typeDescTextMapHash: number;
    useLevel: number;
    useOnGain: boolean;
    useTarget: UseTarget;
    weight: number;
};
declare enum Gofefcodpii {
    MaterialSysTypeBeyond = "MATERIAL_SYS_TYPE_BEYOND",
    MaterialSysTypeNone = "MATERIAL_SYS_TYPE_NONE"
}
declare enum Hjcekdfglcg {
    FilterADVENTURE = "Filter_ADVENTURE",
    FilterATTACK = "Filter_ATTACK",
    FilterDEFENSE = "Filter_DEFENSE",
    FilterHEAL = "Filter_HEAL",
    FilterMEDICAL = "Filter_MEDICAL",
    FilterOTHER = "Filter_OTHER"
}
declare enum Pcopcnfoona {
    AtkUp = "ATK_UP",
    BlackEgg = "BLACK_EGG",
    ColdResist = "Cold_Resist",
    CritUp = "CRIT_UP",
    DefUp = "DEF_UP",
    EFFIktomisaurus = "Eff_Iktomisaurus",
    EFFKoholasaurus = "Eff_Koholasaurus",
    EFFQucusaurus = "Eff_Qucusaurus",
    EFFTatankasaurus = "Eff_Tatankasaurus",
    EFFTepetlisaurus = "Eff_Tepetlisaurus",
    EFFYumkasaurus = "Eff_Yumkasaurus",
    HappyWater = "Happy_Water",
    HealOvertime = "Heal_Overtime",
    HealingUP = "Healing_UP",
    HolyWater = "Holy_Water",
    MaxHPUp = "MAX_HP_UP",
    None = "None",
    PhysicalDMGUP = "Physical_DMG_UP",
    RandomReconvery = "Random_Reconvery",
    Recovery = "Recovery",
    RecoveryByChest = "Recovery_By_Chest",
    Revive = "Revive",
    STAClimbReduce = "STA_Climb_Reduce",
    STAFlyReduce = "STA_Fly_Reduce",
    STARecovery = "STA_Recovery",
    STARecoveryByKill = "STA_Recovery_By_Kill",
    STASprintReduce = "STA_Sprint_Reduce",
    ShieldStrength = "Shield_Strength"
}
declare enum DestroyRule$2 {
    DestroyNone = "DESTROY_NONE",
    DestroyReturnMaterial = "DESTROY_RETURN_MATERIAL"
}
declare enum EffectIcon {
    Empty = "",
    UIBuffFireworks = "UI_Buff_Fireworks",
    UIBuffItemAdventure = "UI_Buff_Item_Adventure",
    UIBuffItemAtkAdd = "UI_Buff_Item_Atk_Add",
    UIBuffItemAtkCritRate = "UI_Buff_Item_Atk_CritRate",
    UIBuffItemAtkElementHurtElect = "UI_Buff_Item_Atk_ElementHurt_Elect",
    UIBuffItemAtkElementHurtFire = "UI_Buff_Item_Atk_ElementHurt_Fire",
    UIBuffItemAtkElementHurtGrass = "UI_Buff_Item_Atk_ElementHurt_Grass",
    UIBuffItemAtkElementHurtIce = "UI_Buff_Item_Atk_ElementHurt_Ice",
    UIBuffItemAtkElementHurtRock = "UI_Buff_Item_Atk_ElementHurt_Rock",
    UIBuffItemAtkElementHurtWater = "UI_Buff_Item_Atk_ElementHurt_Water",
    UIBuffItemAtkElementHurtWind = "UI_Buff_Item_Atk_ElementHurt_Wind",
    UIBuffItemClimateHeat = "UI_Buff_Item_Climate_Heat",
    UIBuffItemDefAdd = "UI_Buff_Item_Def_Add",
    UIBuffItemDefResistanceElect = "UI_Buff_Item_Def_Resistance_Elect",
    UIBuffItemDefResistanceFire = "UI_Buff_Item_Def_Resistance_Fire",
    UIBuffItemDefResistanceGrass = "UI_Buff_Item_Def_Resistance_Grass",
    UIBuffItemDefResistanceIce = "UI_Buff_Item_Def_Resistance_Ice",
    UIBuffItemDefResistanceRock = "UI_Buff_Item_Def_Resistance_Rock",
    UIBuffItemDefResistanceWater = "UI_Buff_Item_Def_Resistance_Water",
    UIBuffItemDefResistanceWind = "UI_Buff_Item_Def_Resistance_Wind",
    UIBuffItemOtherSPAdd = "UI_Buff_Item_Other_SPAdd",
    UIBuffItemOtherSPReduceConsume = "UI_Buff_Item_Other_SPReduceConsume",
    UIBuffItemRecoveryHPAdd = "UI_Buff_Item_Recovery_HpAdd",
    UIBuffItemRecoveryHPAddAll = "UI_Buff_Item_Recovery_HpAddAll",
    UIBuffItemRecoveryRevive = "UI_Buff_Item_Recovery_Revive",
    UIBuffItemSpecialEffect = "UI_Buff_Item_SpecialEffect"
}
declare enum EffectName {
    EFFRockCrystalAbsorb = "Eff_RockCrystal_Absorb",
    EFFSceneObjCelestiaSplinterAbsorb = "Eff_SceneObj_CelestiaSplinter_Absorb",
    EFFSceneObjDendroCrystalAbsorb = "Eff_SceneObj_DendroCrystal_Absorb",
    EFFSceneObjElectricCrystalAbsorb = "Eff_SceneObj_ElectricCrystal_Absorb",
    EFFSceneObjEssenceTreasure01_Absorb = "Eff_SceneObj_EssenceTreasure_01_Absorb",
    EFFSceneObjFontaineCrystalAbsorb = "Eff_SceneObj_FontaineCrystal_Absorb",
    EFFSceneObjLuminousEnergy01_Absorb = "Eff_SceneObj_LuminousEnergy_01_Absorb",
    EFFSceneObjMagicBookPageAbsorb = "Eff_SceneObj_MagicBookPage_Absorb",
    EFFSceneObjMoonlitSigil01_Absorb = "Eff_SceneObj_MoonlitSigil_01_Absorb",
    EFFSceneObjNataCrystalAbsorb = "Eff_SceneObj_NataCrystal_Absorb",
    EFFSceneObjNodKraiCrystalAbsorb = "Eff_SceneObj_NodKraiCrystal_Absorb",
    EFFSceneObjPenumbraTicketCollect01 = "Eff_SceneObj_PenumbraTicket_Collect_01",
    EFFWindCrystalAbsorb = "Eff_WindCrystal_Absorb",
    Empty = ""
}
declare enum FoodQuality {
    FoodQualityDelicious = "FOOD_QUALITY_DELICIOUS",
    FoodQualityNone = "FOOD_QUALITY_NONE",
    FoodQualityOrdinary = "FOOD_QUALITY_ORDINARY",
    FoodQualityStrange = "FOOD_QUALITY_STRANGE"
}
declare enum ItemType$2 {
    ItemMaterial = "ITEM_MATERIAL",
    ItemVirtual = "ITEM_VIRTUAL"
}
type ItemUse = {
    useOp: UseOp;
    useParam: string[];
};
declare enum UseOp {
    ItemUseAcceptQuest = "ITEM_USE_ACCEPT_QUEST",
    ItemUseAddAlchemySimItem = "ITEM_USE_ADD_ALCHEMY_SIM_ITEM",
    ItemUseAddAllEnergy = "ITEM_USE_ADD_ALL_ENERGY",
    ItemUseAddAvatarExtraProperty = "ITEM_USE_ADD_AVATAR_EXTRA_PROPERTY",
    ItemUseAddChannellerSlabBuff = "ITEM_USE_ADD_CHANNELLER_SLAB_BUFF",
    ItemUseAddCurHP = "ITEM_USE_ADD_CUR_HP",
    ItemUseAddCurStamina = "ITEM_USE_ADD_CUR_STAMINA",
    ItemUseAddDungeonCondTime = "ITEM_USE_ADD_DUNGEON_COND_TIME",
    ItemUseAddElemEnergy = "ITEM_USE_ADD_ELEM_ENERGY",
    ItemUseAddExp = "ITEM_USE_ADD_EXP",
    ItemUseAddItem = "ITEM_USE_ADD_ITEM",
    ItemUseAddMagnetPower = "ITEM_USE_ADD_MAGNET_POWER",
    ItemUseAddPersistStamina = "ITEM_USE_ADD_PERSIST_STAMINA",
    ItemUseAddPhlogiston = "ITEM_USE_ADD_PHLOGISTON",
    ItemUseAddRegionalPlayVar = "ITEM_USE_ADD_REGIONAL_PLAY_VAR",
    ItemUseAddReliquaryExp = "ITEM_USE_ADD_RELIQUARY_EXP",
    ItemUseAddSelectItem = "ITEM_USE_ADD_SELECT_ITEM",
    ItemUseAddServerBuff = "ITEM_USE_ADD_SERVER_BUFF",
    ItemUseAddTemporaryStamina = "ITEM_USE_ADD_TEMPORARY_STAMINA",
    ItemUseAddWeaponExp = "ITEM_USE_ADD_WEAPON_EXP",
    ItemUseAddWeaponSkin = "ITEM_USE_ADD_WEAPON_SKIN",
    ItemUseCheckFormalAvatar = "ITEM_USE_CHECK_FORMAL_AVATAR",
    ItemUseChestSelectItem = "ITEM_USE_CHEST_SELECT_ITEM",
    ItemUseCombineItem = "ITEM_USE_COMBINE_ITEM",
    ItemUseGainAvatar = "ITEM_USE_GAIN_AVATAR",
    ItemUseGainAvatarTalentMaterial = "ITEM_USE_GAIN_AVATAR_TALENT_MATERIAL",
    ItemUseGainCardProduct = "ITEM_USE_GAIN_CARD_PRODUCT",
    ItemUseGainCostume = "ITEM_USE_GAIN_COSTUME",
    ItemUseGainFlycloak = "ITEM_USE_GAIN_FLYCLOAK",
    ItemUseGainGcgCard = "ITEM_USE_GAIN_GCG_CARD",
    ItemUseGainGcgCardBack = "ITEM_USE_GAIN_GCG_CARD_BACK",
    ItemUseGainGcgCardFace = "ITEM_USE_GAIN_GCG_CARD_FACE",
    ItemUseGainGcgCardField = "ITEM_USE_GAIN_GCG_CARD_FIELD",
    ItemUseGainNameCard = "ITEM_USE_GAIN_NAME_CARD",
    ItemUseGrantSelectReward = "ITEM_USE_GRANT_SELECT_REWARD",
    ItemUseMakeGadget = "ITEM_USE_MAKE_GADGET",
    ItemUseMusicGameBookUnlockTheme = "ITEM_USE_MUSIC_GAME_BOOK_UNLOCK_THEME",
    ItemUseNone = "ITEM_USE_NONE",
    ItemUseOpenDropExtra = "ITEM_USE_OPEN_DROP_EXTRA",
    ItemUseOpenRandomChest = "ITEM_USE_OPEN_RANDOM_CHEST",
    ItemUseOpenRenameDialog = "ITEM_USE_OPEN_RENAME_DIALOG",
    ItemUseReliveAvatar = "ITEM_USE_RELIVE_AVATAR",
    ItemUseSetOpenState = "ITEM_USE_SET_OPEN_STATE",
    ItemUseUnlockAvatarTrace = "ITEM_USE_UNLOCK_AVATAR_TRACE",
    ItemUseUnlockCodex = "ITEM_USE_UNLOCK_CODEX",
    ItemUseUnlockCombine = "ITEM_USE_UNLOCK_COMBINE",
    ItemUseUnlockCookRecipe = "ITEM_USE_UNLOCK_COOK_RECIPE",
    ItemUseUnlockForge = "ITEM_USE_UNLOCK_FORGE",
    ItemUseUnlockFurnitureFormula = "ITEM_USE_UNLOCK_FURNITURE_FORMULA",
    ItemUseUnlockFurnitureSuite = "ITEM_USE_UNLOCK_FURNITURE_SUITE",
    ItemUseUnlockHomeBgm = "ITEM_USE_UNLOCK_HOME_BGM",
    ItemUseUnlockHomeModule = "ITEM_USE_UNLOCK_HOME_MODULE",
    ItemUseUnlockNormalBeyondBattlePass = "ITEM_USE_UNLOCK_NORMAL_BEYOND_BATTLE_PASS",
    ItemUseUnlockPaidBattlePassNormal = "ITEM_USE_UNLOCK_PAID_BATTLE_PASS_NORMAL",
    ItemUseUnlockPhotographPose = "ITEM_USE_UNLOCK_PHOTOGRAPH_POSE",
    ItemUseUnlockProfileFrame = "ITEM_USE_UNLOCK_PROFILE_FRAME",
    ItemUseUnlockProfilePicture = "ITEM_USE_UNLOCK_PROFILE_PICTURE"
}
declare enum MaterialType$1 {
    MaterialActivityGear = "MATERIAL_ACTIVITY_GEAR",
    MaterialActivityJigsaw = "MATERIAL_ACTIVITY_JIGSAW",
    MaterialActivityRobot = "MATERIAL_ACTIVITY_ROBOT",
    MaterialAdsorbate = "MATERIAL_ADSORBATE",
    MaterialAranara = "MATERIAL_ARANARA",
    MaterialAvatar = "MATERIAL_AVATAR",
    MaterialAvatarMaterial = "MATERIAL_AVATAR_MATERIAL",
    MaterialAvatarTalentMaterial = "MATERIAL_AVATAR_TALENT_MATERIAL",
    MaterialAvatarTrace = "MATERIAL_AVATAR_TRACE",
    MaterialBgm = "MATERIAL_BGM",
    MaterialChannellerSlabBuff = "MATERIAL_CHANNELLER_SLAB_BUFF",
    MaterialChest = "MATERIAL_CHEST",
    MaterialChestBatchUse = "MATERIAL_CHEST_BATCH_USE",
    MaterialChestBatchUseWithGroup = "MATERIAL_CHEST_BATCH_USE_WITH_GROUP",
    MaterialClueShopHandbook = "MATERIAL_CLUE_SHOP_HANDBOOK",
    MaterialConsume = "MATERIAL_CONSUME",
    MaterialConsumeBatchUse = "MATERIAL_CONSUME_BATCH_USE",
    MaterialCostume = "MATERIAL_COSTUME",
    MaterialCricket = "MATERIAL_CRICKET",
    MaterialDeshretManual = "MATERIAL_DESHRET_MANUAL",
    MaterialElemCrystal = "MATERIAL_ELEM_CRYSTAL",
    MaterialExchange = "MATERIAL_EXCHANGE",
    MaterialExpFruit = "MATERIAL_EXP_FRUIT",
    MaterialFakeAbsorbate = "MATERIAL_FAKE_ABSORBATE",
    MaterialFireMasterAvatarTalentItem = "MATERIAL_FIRE_MASTER_AVATAR_TALENT_ITEM",
    MaterialFireworks = "MATERIAL_FIREWORKS",
    MaterialFishBait = "MATERIAL_FISH_BAIT",
    MaterialFishRod = "MATERIAL_FISH_ROD",
    MaterialFlycloak = "MATERIAL_FLYCLOAK",
    MaterialFood = "MATERIAL_FOOD",
    MaterialFurnitureFormula = "MATERIAL_FURNITURE_FORMULA",
    MaterialFurnitureSuiteFormula = "MATERIAL_FURNITURE_SUITE_FORMULA",
    MaterialGcgCard = "MATERIAL_GCG_CARD",
    MaterialGcgCardBack = "MATERIAL_GCG_CARD_BACK",
    MaterialGcgCardFace = "MATERIAL_GCG_CARD_FACE",
    MaterialGcgExchangeItem = "MATERIAL_GCG_EXCHANGE_ITEM",
    MaterialGcgField = "MATERIAL_GCG_FIELD",
    MaterialGreatefestivalv2Invite = "MATERIAL_GREATEFESTIVALV2_INVITE",
    MaterialHolidayMemoryBook = "MATERIAL_HOLIDAY_MEMORY_BOOK",
    MaterialHolidayResortInvite = "MATERIAL_HOLIDAY_RESORT_INVITE",
    MaterialHomeSeed = "MATERIAL_HOME_SEED",
    MaterialLanv5PaimonGreetingCard = "MATERIAL_LANV5_PAIMON_GREETING_CARD",
    MaterialMagicStoryBook = "MATERIAL_MAGIC_STORY_BOOK",
    MaterialMikawaFlowerInvite = "MATERIAL_MIKAWA_FLOWER_INVITE",
    MaterialMoonNightCard = "MATERIAL_MOON_NIGHT_CARD",
    MaterialMusicGameBookTheme = "MATERIAL_MUSIC_GAME_BOOK_THEME",
    MaterialNamecard = "MATERIAL_NAMECARD",
    MaterialNatlanRaceAlbum = "MATERIAL_NATLAN_RACE_ALBUM",
    MaterialNatlanRaceEnvelope = "MATERIAL_NATLAN_RACE_ENVELOPE",
    MaterialNatlanRelationA = "MATERIAL_NATLAN_RELATION_A",
    MaterialNatlanRelationB = "MATERIAL_NATLAN_RELATION_B",
    MaterialNone = "MATERIAL_NONE",
    MaterialNoticeAddHP = "MATERIAL_NOTICE_ADD_HP",
    MaterialPhotoDisplayBook = "MATERIAL_PHOTO_DISPLAY_BOOK",
    MaterialPhotographPose = "MATERIAL_PHOTOGRAPH_POSE",
    MaterialPhotov5HandBook = "MATERIAL_PHOTOV5_HAND_BOOK",
    MaterialPhotov6HandBook = "MATERIAL_PHOTOV6_HAND_BOOK",
    MaterialProfileFrame = "MATERIAL_PROFILE_FRAME",
    MaterialProfilePicture = "MATERIAL_PROFILE_PICTURE",
    MaterialQuest = "MATERIAL_QUEST",
    MaterialQuestAlbum = "MATERIAL_QUEST_ALBUM",
    MaterialQuestEventBook = "MATERIAL_QUEST_EVENT_BOOK",
    MaterialRainbowPrinceHandBook = "MATERIAL_RAINBOW_PRINCE_HAND_BOOK",
    MaterialRareGrowthMaterial = "MATERIAL_RARE_GROWTH_MATERIAL",
    MaterialReliquaryMaterial = "MATERIAL_RELIQUARY_MATERIAL",
    MaterialRemusMusicBox = "MATERIAL_REMUS_MUSIC_BOX",
    MaterialRenameItem = "MATERIAL_RENAME_ITEM",
    MaterialRoboGift = "MATERIAL_ROBO_GIFT",
    MaterialSeaLamp = "MATERIAL_SEA_LAMP",
    MaterialSelectableChest = "MATERIAL_SELECTABLE_CHEST",
    MaterialSpiceFood = "MATERIAL_SPICE_FOOD",
    MaterialTalent = "MATERIAL_TALENT",
    MaterialWeaponExpStone = "MATERIAL_WEAPON_EXP_STONE",
    MaterialWeaponSkin = "MATERIAL_WEAPON_SKIN",
    MaterialWidget = "MATERIAL_WIDGET",
    MaterialWood = "MATERIAL_WOOD"
}
declare enum UseTarget {
    ItemUseTargetCurTeam = "ITEM_USE_TARGET_CUR_TEAM",
    ItemUseTargetNone = "ITEM_USE_TARGET_NONE",
    ItemUseTargetPlayerAvatar = "ITEM_USE_TARGET_PLAYER_AVATAR",
    ItemUseTargetSpecifyAliveAvatar = "ITEM_USE_TARGET_SPECIFY_ALIVE_AVATAR",
    ItemUseTargetSpecifyAvatar = "ITEM_USE_TARGET_SPECIFY_AVATAR",
    ItemUseTargetSpecifyDeadAvatar = "ITEM_USE_TARGET_SPECIFY_DEAD_AVATAR"
}

type MonsterCurveExcelConfigDataType = {
    curveInfos: CurveInfo$1[];
    level: number;
};
type CurveInfo$1 = {
    arith: Arith$1;
    type: Type$3;
    value: number;
};
declare enum Arith$1 {
    ArithAdd = "ARITH_ADD",
    ArithMulti = "ARITH_MULTI"
}
declare enum Type$3 {
    GrowCurveActivityAttack1 = "GROW_CURVE_ACTIVITY_ATTACK_1",
    GrowCurveActivityAttack2 = "GROW_CURVE_ACTIVITY_ATTACK_2",
    GrowCurveActivityDefense2 = "GROW_CURVE_ACTIVITY_DEFENSE_2",
    GrowCurveActivityHP1 = "GROW_CURVE_ACTIVITY_HP_1",
    GrowCurveActivityHP2 = "GROW_CURVE_ACTIVITY_HP_2",
    GrowCurveAttack = "GROW_CURVE_ATTACK",
    GrowCurveAttack2 = "GROW_CURVE_ATTACK_2",
    GrowCurveDefense = "GROW_CURVE_DEFENSE",
    GrowCurveElement = "GROW_CURVE_ELEMENT",
    GrowCurveHP = "GROW_CURVE_HP",
    GrowCurveHP2 = "GROW_CURVE_HP_2",
    GrowCurveHPEnvironment = "GROW_CURVE_HP_ENVIRONMENT",
    GrowCurveHPLittlemonster = "GROW_CURVE_HP_LITTLEMONSTER",
    GrowCurveKillExp = "GROW_CURVE_KILL_EXP",
    GrowCurveMatk = "GROW_CURVE_MATK",
    GrowCurveMhp = "GROW_CURVE_MHP",
    GrowCurveStrike = "GROW_CURVE_STRIKE",
    GrowCurveStrikeHurt = "GROW_CURVE_STRIKE_HURT"
}

type MonsterDescribeExcelConfigDataType = {
    icon: string;
    id: number;
    nameTextMapHash: number;
    specialNameLabID: number;
    titleID: number;
};

type MonsterExcelConfigDataType = {
    CIAPMJAEIHD: number;
    affix: number[];
    ai: AI;
    combatBGMLevel: number;
    attackBase: number;
    critical: number;
    criticalHurt: number;
    campID: number;
    canSwim: boolean;
    defenseBase: number;
    combatConfigHash: number;
    controllerPathHash: number;
    controllerPathRemoteHash: number;
    deformationMeshPathHash: number;
    elecSubHurt: number;
    elementMastery: number;
    fireSubHurt: number;
    describeId: number;
    grassSubHurt: number;
    iceSubHurt: number;
    entityBudgetLevel: number;
    equips: number[];
    excludeWeathers: ExcludeWeathers;
    featureTagGroupID: number;
    PJFIHJIKDDI: number[];
    IFNGBLPHINC: number;
    ILDGFINBLII: number;
    IOMANLCNFEO: number;
    FCAHMCPMPNP: boolean;
    hpBase: number;
    hpDrops: HPDrop[];
    JEOILPDPBCF: number;
    id: number;
    KGOGCJLGLNI: number;
    hideNameInElementView: boolean;
    isAIHashCheck: boolean;
    PPMJAMDEFFO: Ppmjamdeffo;
    killDropId: number;
    NCLJNCFOILK: number;
    isInvisibleReset: boolean;
    NKGIPKIAOGH: number;
    lodPatternName: LodPatternName;
    monsterName: string;
    mpPropID: number;
    nameTextMapHash: number;
    PBJALANPDBD: number;
    playType: PlayType;
    physicalSubHurt: number;
    prefabPathHash: number;
    prefabPathRagdollHash: number;
    prefabPathRemoteHash: number;
    propGrowCurves: PropGrowCurve[];
    radarHintID: number;
    rockSubHurt: number;
    safetyCheck: boolean;
    scriptDataPathHash: number;
    securityLevel: SecurityLevel;
    serverScript: ServerScript;
    skin: string;
    type: MonsterExcelConfigDataTypeType;
    visionLevel: VisionLevel;
    waterSubHurt: number;
    windSubHurt: number;
};
declare enum Ppmjamdeffo {
    None = "None",
    Ousia = "Ousia",
    Pneuma = "Pneuma"
}
declare enum AI {
    Assist01 = "assist01",
    Dragon01 = "dragon01",
    Empty = "",
    Playing = "playing",
    Ranged01 = "ranged01",
    Scout01 = "scout01",
    Sentry02 = "sentry02"
}
declare enum ExcludeWeathers {
    Empty = "",
    雨雷雨雪 = "\u96E8,\u96F7\u96E8,\u96EA",
    雪 = "\u96EA",
    雷雨雪 = "\u96F7\u96E8,\u96EA"
}
type HPDrop = {
    dropId: number;
    hpPercent: number;
};
declare enum LodPatternName {
    AnimalDefault01 = "Animal_Default_01",
    AnimalSpecial200_01 = "Animal_Special_200_01",
    AnimalSpecial20_01 = "Animal_Special_20_01",
    AnimalSpecial40_01 = "Animal_Special_40_01",
    Empty = "",
    MonsterBeydDefaultLod1 = "Monster_Beyd_Default_Lod1",
    MonsterBeydDefaultLod2 = "Monster_Beyd_Default_Lod2",
    MonsterDisplayFar = "Monster_DisplayFar",
    MonsterFlamingoNormalMigrate01 = "Monster_Flamingo_Normal_Migrate_01",
    MonsterGiantChessStage2 = "Monster_GiantChess_Stage2",
    MonsterNarcissusbornNarzissenkreuz01 = "Monster_Narcissusborn_Narzissenkreuz_01",
    MonsterRegisvineElectric01 = "Monster_Regisvine_Electric_01",
    MonsterShootingActivity01 = "Monster_ShootingActivity_01",
    MonsterSpecial200_01 = "Monster_Special_200_01",
    MonsterSpecialDragon01 = "Monster_Special_Dragon_01"
}
declare enum PlayType {
    Beyond = "BEYOND",
    Default = "DEFAULT"
}
type PropGrowCurve = {
    growCurve: GrowCurve;
    type: PropGrowCurveType;
};
declare enum GrowCurve {
    GrowCurveActivityAttack1 = "GROW_CURVE_ACTIVITY_ATTACK_1",
    GrowCurveActivityAttack2 = "GROW_CURVE_ACTIVITY_ATTACK_2",
    GrowCurveActivityDefense2 = "GROW_CURVE_ACTIVITY_DEFENSE_2",
    GrowCurveActivityHP1 = "GROW_CURVE_ACTIVITY_HP_1",
    GrowCurveActivityHP2 = "GROW_CURVE_ACTIVITY_HP_2",
    GrowCurveAttack = "GROW_CURVE_ATTACK",
    GrowCurveAttack2 = "GROW_CURVE_ATTACK_2",
    GrowCurveDefending = "GROW_CURVE_DEFENDING",
    GrowCurveDefense = "GROW_CURVE_DEFENSE",
    GrowCurveHP = "GROW_CURVE_HP",
    GrowCurveHP2 = "GROW_CURVE_HP_2",
    GrowCurveHPEnvironment = "GROW_CURVE_HP_ENVIRONMENT",
    GrowCurveHPLittlemonster = "GROW_CURVE_HP_LITTLEMONSTER",
    GrowCurveNone = "GROW_CURVE_NONE"
}
declare enum PropGrowCurveType {
    FightPropBaseAttack = "FIGHT_PROP_BASE_ATTACK",
    FightPropBaseDefense = "FIGHT_PROP_BASE_DEFENSE",
    FightPropBaseHP = "FIGHT_PROP_BASE_HP",
    FightPropNone = "FIGHT_PROP_NONE"
}
declare enum SecurityLevel {
    Boss = "BOSS",
    Elite = "ELITE",
    Normal = "NORMAL"
}
declare enum ServerScript {
    Empty = "",
    SubFieldDropLightBall = "SubFieldDrop_LightBall",
    SubFieldDropMimikIce = "SubFieldDrop_Mimik_Ice",
    TestMoleMoraDrop = "Test_Mole_MoraDrop"
}
declare enum MonsterExcelConfigDataTypeType {
    MonsterBoss = "MONSTER_BOSS",
    MonsterEnvAnimal = "MONSTER_ENV_ANIMAL",
    MonsterFish = "MONSTER_FISH",
    MonsterOrdinary = "MONSTER_ORDINARY",
    MonsterPartner = "MONSTER_PARTNER"
}
declare enum VisionLevel {
    VisionLevelLittleRemote = "VISION_LEVEL_LITTLE_REMOTE",
    VisionLevelNearby = "VISION_LEVEL_NEARBY",
    VisionLevelNormal = "VISION_LEVEL_NORMAL",
    VisionLevelRemote = "VISION_LEVEL_REMOTE",
    VisionLevelSuper = "VISION_LEVEL_SUPER",
    VisionLevelSuperNearby = "VISION_LEVEL_SUPER_NEARBY"
}

type ProfilePictureExcelConfigDataType = {
    EKFIIIINJCD: boolean;
    OOMIPLHHLGO: boolean;
    iconPath: string;
    id: number;
    type: Type$2;
    nameTextMapHash: number;
    priority: number;
    unlockDescTextMapHash: number;
    unlockParam: number;
};
declare enum Type$2 {
    ProfilePictureUnlockByAvatar = "PROFILE_PICTURE_UNLOCK_BY_AVATAR",
    ProfilePictureUnlockByCostume = "PROFILE_PICTURE_UNLOCK_BY_COSTUME",
    ProfilePictureUnlockByDefault = "PROFILE_PICTURE_UNLOCK_BY_DEFAULT",
    ProfilePictureUnlockByItem = "PROFILE_PICTURE_UNLOCK_BY_ITEM",
    ProfilePictureUnlockByParentQuest = "PROFILE_PICTURE_UNLOCK_BY_PARENT_QUEST"
}

type ProudSkillExcelConfigDataType = {
    addProps: AddProp$2[];
    breakLevel: number;
    coinCost: number;
    costItems: CostItem$1[];
    descTextMapHash: number;
    filterConds: FilterCond[];
    IACNAENANDH: number;
    icon: string;
    IFBLICKNGFI: number[];
    isHideLifeProudSkill: boolean;
    LCNAOPBKNGP: Lcnaopbkngp;
    level: number;
    lifeEffectParams: string[];
    lifeEffectType: LifeEffectType;
    LPNPFAMOHIH: number;
    MLMBNEJOEHI: number[];
    nameTextMapHash: number;
    CIJGPJNCAKN: Cijgpjncakn;
    openConfig: string;
    paramDescList: number[];
    paramList: number[];
    proudSkillGroupId: number;
    proudSkillId: number;
    proudSkillType: number;
    unlockDescTextMapHash: number;
};
declare enum Cijgpjncakn {
    ProudSkillDisplayBreak = "PROUD_SKILL_DISPLAY_BREAK",
    ProudSkillDisplayDefault = "PROUD_SKILL_DISPLAY_DEFAULT",
    ProudSkillDisplayHexenzirkel = "PROUD_SKILL_DISPLAY_HEXENZIRKEL"
}
type Lcnaopbkngp = {
    value: number;
};
type AddProp$2 = {
    propType: PropType$3;
    value: number;
};
declare enum PropType$3 {
    FightPropCritical = "FIGHT_PROP_CRITICAL",
    FightPropHealAdd = "FIGHT_PROP_HEAL_ADD",
    FightPropNone = "FIGHT_PROP_NONE",
    FightPropWaterAddHurt = "FIGHT_PROP_WATER_ADD_HURT"
}
type CostItem$1 = {
    count: number;
    id: number;
};
declare enum FilterCond {
    TalentFilterNone = "TALENT_FILTER_NONE"
}
declare enum LifeEffectType {
    ProudEffectCombineMultiplyOutput = "PROUD_EFFECT_COMBINE_MULTIPLY_OUTPUT",
    ProudEffectCombineReturnMaterial = "PROUD_EFFECT_COMBINE_RETURN_MATERIAL",
    ProudEffectCombineReturnSpecialMaterial = "PROUD_EFFECT_COMBINE_RETURN_SPECIAL_MATERIAL",
    ProudEffectCookCanNotCook = "PROUD_EFFECT_COOK_CAN_NOT_COOK",
    ProudEffectCookPerfectMultiOutput = "PROUD_EFFECT_COOK_PERFECT_MULTI_OUTPUT",
    ProudEffectCookProbMultiOutput = "PROUD_EFFECT_COOK_PROB_MULTI_OUTPUT",
    ProudEffectExpeditionExtraOutput = "PROUD_EFFECT_EXPEDITION_EXTRA_OUTPUT",
    ProudEffectExpeditionShortenTime = "PROUD_EFFECT_EXPEDITION_SHORTEN_TIME",
    ProudEffectFishingExtraOutput = "PROUD_EFFECT_FISHING_EXTRA_OUTPUT",
    ProudEffectForgeAddExtraProb = "PROUD_EFFECT_FORGE_ADD_EXTRA_PROB",
    ProudEffectForgeReduceTime = "PROUD_EFFECT_FORGE_REDUCE_TIME",
    ProudEffectForgeReturnMaterial = "PROUD_EFFECT_FORGE_RETURN_MATERIAL",
    ProudEffectFurnitureMakeReturnMaterial = "PROUD_EFFECT_FURNITURE_MAKE_RETURN_MATERIAL",
    ProudEffectHitTreeExtraOutput = "PROUD_EFFECT_HIT_TREE_EXTRA_OUTPUT",
    ProudEffectNone = "PROUD_EFFECT_NONE",
    ProudEffectUseFoodProbGetItem = "PROUD_EFFECT_USE_FOOD_PROB_GET_ITEM",
    ProudEffectWeaponPromoteReduceScoin = "PROUD_EFFECT_WEAPON_PROMOTE_REDUCE_SCOIN"
}

type ReliquaryAffixExcelConfigDataType = {
    depotId: number;
    groupId: number;
    id: number;
    propType: string;
    propValue: number;
};

type ReliquaryExcelConfigDataType = {
    addPropLevels: number[];
    appendPropDepotId: number;
    appendPropNum: number;
    baseConvExp: number;
    descTextMapHash: number;
    destroyReturnMaterial: number[];
    destroyReturnMaterialCount: number[];
    destroyRule: DestroyRule$1;
    dropable: boolean;
    equipType: EquipType;
    gadgetId: number;
    globalItemLimit: number;
    icon: string;
    id: number;
    initialLockState: number;
    itemType: ItemType$1;
    mainPropDepotId: number;
    maxLevel: number;
    nameTextMapHash: number;
    rank: number;
    rankLevel: number;
    setId: number;
    showPic: string;
    storyId: number;
    useLevel: number;
    weight: number;
};
declare enum DestroyRule$1 {
    DestroyNone = "DESTROY_NONE",
    DestroyReturnMaterial = "DESTROY_RETURN_MATERIAL"
}
declare enum EquipType {
    EquipBracer = "EQUIP_BRACER",
    EquipDress = "EQUIP_DRESS",
    EquipNecklace = "EQUIP_NECKLACE",
    EquipRing = "EQUIP_RING",
    EquipShoes = "EQUIP_SHOES"
}
declare enum ItemType$1 {
    ItemReliquary = "ITEM_RELIQUARY"
}

type ReliquaryLevelExcelConfigDataType = {
    addProps: AddProp$1[];
    exp: number;
    level: number;
    rank: number;
};
type AddProp$1 = {
    propType: PropType$2;
    value: number;
};
declare enum PropType$2 {
    FightPropAttack = "FIGHT_PROP_ATTACK",
    FightPropAttackPercent = "FIGHT_PROP_ATTACK_PERCENT",
    FightPropChargeEfficiency = "FIGHT_PROP_CHARGE_EFFICIENCY",
    FightPropCritical = "FIGHT_PROP_CRITICAL",
    FightPropCriticalHurt = "FIGHT_PROP_CRITICAL_HURT",
    FightPropDefense = "FIGHT_PROP_DEFENSE",
    FightPropDefensePercent = "FIGHT_PROP_DEFENSE_PERCENT",
    FightPropElecAddHurt = "FIGHT_PROP_ELEC_ADD_HURT",
    FightPropElementMastery = "FIGHT_PROP_ELEMENT_MASTERY",
    FightPropFireAddHurt = "FIGHT_PROP_FIRE_ADD_HURT",
    FightPropFireSubHurt = "FIGHT_PROP_FIRE_SUB_HURT",
    FightPropGrassAddHurt = "FIGHT_PROP_GRASS_ADD_HURT",
    FightPropHP = "FIGHT_PROP_HP",
    FightPropHPPercent = "FIGHT_PROP_HP_PERCENT",
    FightPropHealAdd = "FIGHT_PROP_HEAL_ADD",
    FightPropIceAddHurt = "FIGHT_PROP_ICE_ADD_HURT",
    FightPropPhysicalAddHurt = "FIGHT_PROP_PHYSICAL_ADD_HURT",
    FightPropRockAddHurt = "FIGHT_PROP_ROCK_ADD_HURT",
    FightPropWaterAddHurt = "FIGHT_PROP_WATER_ADD_HURT",
    FightPropWindAddHurt = "FIGHT_PROP_WIND_ADD_HURT"
}

type ReliquaryMainPropExcelConfigDataType = {
    affixName: string;
    id: number;
    propDepotId: number;
    propType: string;
};

type ReliquarySetExcelConfigDataType = {
    bagSortValue: number;
    containsList: number[];
    disableFilter: number;
    DKBIAAFLNOB: number;
    dungeonGroup: number[];
    equipAffixId: number;
    setIcon: string;
    setId: number;
    setNeedNum: number[];
    textList: number[];
};

type TowerFloorExcelConfigDataType = {
    bgImage: BgImage;
    floorId: number;
    floorIndex: number;
    floorLevelConfigId: number;
    levelGroupId: number;
    KFMMFLCOBBN: number;
    PGMLCDGLAKK: number;
    overrideMonsterLevel: number;
    rewardIdFifteenStars: number;
    rewardIdFiveStars: number;
    rewardIdNineStars: number;
    rewardIdSixStars: number;
    rewardIdTenStars: number;
    rewardIdThreeStars: number;
    teamNum: number;
    unlockStarCount: number;
};
declare enum BgImage {
    UITowerPic1 = "UI_TowerPic_1",
    UITowerPic10 = "UI_TowerPic_10",
    UITowerPic11 = "UI_TowerPic_11",
    UITowerPic2 = "UI_TowerPic_2",
    UITowerPic3 = "UI_TowerPic_3",
    UITowerPic4 = "UI_TowerPic_4",
    UITowerPic5 = "UI_TowerPic_5",
    UITowerPic8 = "UI_TowerPic_8",
    UITowerPic9 = "UI_TowerPic_9"
}

type TowerLevelExcelConfigDataType = {
    AGEAANNELOI: number;
    conds: Cond[];
    dungeonId: number;
    firstMonsterList: number[];
    firstPassRewardId: number;
    KLNFCGKDKGE: string;
    ILCLLJANFMK: number;
    JKMIPCBDBPM: number;
    levelGroupId: number;
    levelId: number;
    levelIndex: number;
    monsterLevel: number;
    secondMonsterList: number[];
    towerBuffConfigStrList: string[];
};
type Cond = {
    argumentList: number[];
    argumentListUpper: number[];
    towerCondType: TowerCondType;
};
declare enum TowerCondType {
    TowerCondChallengeLeftTimeMoreThan = "TOWER_COND_CHALLENGE_LEFT_TIME_MORE_THAN",
    TowerCondLeftHPGreaterThan = "TOWER_COND_LEFT_HP_GREATER_THAN"
}

type TowerScheduleExcelConfigDataType = {
    buffnameTextMapHash: number;
    closeTime: Date;
    descTextMapHash: number;
    entranceFloorId: number[];
    icon: string;
    EGJACBLKAKB: Egjacblkakb[];
    CGBJKDEDNFN: Cgbjkdednfn[];
    monthlyLevelConfigId: number;
    KKCEHFCCICG: number;
    FHEEAFHBJHA: number;
    rewardGroup: number;
    scheduleId: number;
};
type Cgbjkdednfn = {
    GMMMCFJJNOF?: number[];
    LIAMLMJIGNK: string;
    JAGPCPNDKMB?: any[];
};
type Egjacblkakb = {
    CPLCFNJNBEI: number;
    rewardId: number;
};

type WeaponCurveExcelConfigDataType = {
    curveInfos: CurveInfo[];
    level: number;
};
type CurveInfo = {
    arith: Arith;
    type: Type$1;
    value: number;
};
declare enum Arith {
    ArithMulti = "ARITH_MULTI"
}
declare enum Type$1 {
    GrowCurveAttack101 = "GROW_CURVE_ATTACK_101",
    GrowCurveAttack102 = "GROW_CURVE_ATTACK_102",
    GrowCurveAttack103 = "GROW_CURVE_ATTACK_103",
    GrowCurveAttack104 = "GROW_CURVE_ATTACK_104",
    GrowCurveAttack105 = "GROW_CURVE_ATTACK_105",
    GrowCurveAttack201 = "GROW_CURVE_ATTACK_201",
    GrowCurveAttack202 = "GROW_CURVE_ATTACK_202",
    GrowCurveAttack203 = "GROW_CURVE_ATTACK_203",
    GrowCurveAttack204 = "GROW_CURVE_ATTACK_204",
    GrowCurveAttack205 = "GROW_CURVE_ATTACK_205",
    GrowCurveAttack301 = "GROW_CURVE_ATTACK_301",
    GrowCurveAttack302 = "GROW_CURVE_ATTACK_302",
    GrowCurveAttack303 = "GROW_CURVE_ATTACK_303",
    GrowCurveAttack304 = "GROW_CURVE_ATTACK_304",
    GrowCurveAttack305 = "GROW_CURVE_ATTACK_305",
    GrowCurveCritical101 = "GROW_CURVE_CRITICAL_101",
    GrowCurveCritical201 = "GROW_CURVE_CRITICAL_201",
    GrowCurveCritical301 = "GROW_CURVE_CRITICAL_301"
}

type WeaponExcelConfigDataType = {
    awakenCosts: number[];
    awakenIcon: string;
    awakenLightMapTexture: string;
    awakenMaterial: number;
    awakenTexture: string;
    PDAEIKHKCBP: Pdaeikhkcbp;
    descTextMapHash: number;
    destroyReturnMaterial: number[];
    destroyReturnMaterialCount: number[];
    destroyRule: DestroyRule;
    dropable: boolean;
    gachaCardNameHash: number;
    gadgetId: number;
    DLIALKLHDED: number;
    KCCFDAFPBCI: boolean;
    icon: string;
    id: number;
    globalItemLimit: number;
    itemType: ItemType;
    initialLockState: number;
    materialType: MaterialType;
    nameTextMapHash: number;
    rank: number;
    rankLevel: number;
    skillAffix: number[];
    storyId: number;
    unRotate: boolean;
    useLevel: number;
    weaponBaseExp: number;
    weaponPromoteId: number;
    weaponProp: WeaponProp[];
    weaponType: WeaponType;
    weight: number;
};
declare enum Pdaeikhkcbp {
    None = "None"
}
declare enum DestroyRule {
    DestroyNone = "DESTROY_NONE",
    DestroyReturnMaterial = "DESTROY_RETURN_MATERIAL"
}
declare enum ItemType {
    ItemWeapon = "ITEM_WEAPON"
}
declare enum MaterialType {
    WeaponMaterialNone = "WEAPON_MATERIAL_NONE"
}
type WeaponProp = {
    initValue: number;
    propType: PropType$1;
    type: Type;
};
declare enum PropType$1 {
    FightPropAttackPercent = "FIGHT_PROP_ATTACK_PERCENT",
    FightPropBaseAttack = "FIGHT_PROP_BASE_ATTACK",
    FightPropChargeEfficiency = "FIGHT_PROP_CHARGE_EFFICIENCY",
    FightPropCritical = "FIGHT_PROP_CRITICAL",
    FightPropCriticalHurt = "FIGHT_PROP_CRITICAL_HURT",
    FightPropDefensePercent = "FIGHT_PROP_DEFENSE_PERCENT",
    FightPropElementMastery = "FIGHT_PROP_ELEMENT_MASTERY",
    FightPropHPPercent = "FIGHT_PROP_HP_PERCENT",
    FightPropNone = "FIGHT_PROP_NONE",
    FightPropPhysicalAddHurt = "FIGHT_PROP_PHYSICAL_ADD_HURT"
}
declare enum Type {
    GrowCurveAttack101 = "GROW_CURVE_ATTACK_101",
    GrowCurveAttack102 = "GROW_CURVE_ATTACK_102",
    GrowCurveAttack104 = "GROW_CURVE_ATTACK_104",
    GrowCurveAttack201 = "GROW_CURVE_ATTACK_201",
    GrowCurveAttack202 = "GROW_CURVE_ATTACK_202",
    GrowCurveAttack203 = "GROW_CURVE_ATTACK_203",
    GrowCurveAttack204 = "GROW_CURVE_ATTACK_204",
    GrowCurveAttack301 = "GROW_CURVE_ATTACK_301",
    GrowCurveAttack302 = "GROW_CURVE_ATTACK_302",
    GrowCurveAttack303 = "GROW_CURVE_ATTACK_303",
    GrowCurveAttack304 = "GROW_CURVE_ATTACK_304",
    GrowCurveCritical101 = "GROW_CURVE_CRITICAL_101",
    GrowCurveCritical201 = "GROW_CURVE_CRITICAL_201",
    GrowCurveCritical301 = "GROW_CURVE_CRITICAL_301"
}
declare enum WeaponType {
    WeaponBow = "WEAPON_BOW",
    WeaponCatalyst = "WEAPON_CATALYST",
    WeaponClaymore = "WEAPON_CLAYMORE",
    WeaponPole = "WEAPON_POLE",
    WeaponSwordOneHand = "WEAPON_SWORD_ONE_HAND"
}

type WeaponPromoteExcelConfigDataType = {
    addProps: AddProp[];
    coinCost: number;
    costItems: CostItem[];
    promoteLevel: number;
    requiredPlayerLevel: number;
    unlockMaxLevel: number;
    weaponPromoteId: number;
};
type AddProp = {
    propType: PropType;
    value: number;
};
declare enum PropType {
    FightPropBaseAttack = "FIGHT_PROP_BASE_ATTACK",
    FightPropChargeEfficiency = "FIGHT_PROP_CHARGE_EFFICIENCY",
    FightPropCritical = "FIGHT_PROP_CRITICAL",
    FightPropCriticalHurt = "FIGHT_PROP_CRITICAL_HURT",
    FightPropElementMastery = "FIGHT_PROP_ELEMENT_MASTERY"
}
type CostItem = {
    count: number;
    id: number;
};

/**
 * Master file type mapping
 * Maps ExcelBinOutput file names to their corresponding decoded types
 */
interface MasterFileMap {
    AnimalCodexExcelConfigData: AnimalCodexExcelConfigDataType;
    AvatarCostumeExcelConfigData: AvatarCostumeExcelConfigDataType;
    AvatarCurveExcelConfigData: AvatarCurveExcelConfigDataType;
    AvatarExcelConfigData: AvatarExcelConfigDataType;
    AvatarPromoteExcelConfigData: AvatarPromoteExcelConfigDataType;
    AvatarSkillDepotExcelConfigData: AvatarSkillDepotExcelConfigDataType;
    AvatarSkillExcelConfigData: AvatarSkillExcelConfigDataType;
    AvatarTalentExcelConfigData: AvatarTalentExcelConfigDataType;
    DungeonEntryExcelConfigData: DungeonEntryExcelConfigDataType;
    DungeonLevelEntityConfigData: DungeonLevelEntityConfigDataType;
    EquipAffixExcelConfigData: EquipAffixExcelConfigDataType;
    FetterInfoExcelConfigData: FetterInfoExcelConfigDataType;
    FettersExcelConfigData: FettersExcelConfigDataType;
    FetterStoryExcelConfigData: FetterStoryExcelConfigDataType;
    ManualTextMapConfigData: ManualTextMapConfigDataType;
    MaterialExcelConfigData: MaterialExcelConfigDataType;
    MonsterCurveExcelConfigData: MonsterCurveExcelConfigDataType;
    MonsterDescribeExcelConfigData: MonsterDescribeExcelConfigDataType;
    MonsterExcelConfigData: MonsterExcelConfigDataType;
    ProfilePictureExcelConfigData: ProfilePictureExcelConfigDataType;
    ProudSkillExcelConfigData: ProudSkillExcelConfigDataType;
    ReliquaryAffixExcelConfigData: ReliquaryAffixExcelConfigDataType;
    ReliquaryExcelConfigData: ReliquaryExcelConfigDataType;
    ReliquaryLevelExcelConfigData: ReliquaryLevelExcelConfigDataType;
    ReliquaryMainPropExcelConfigData: ReliquaryMainPropExcelConfigDataType;
    ReliquarySetExcelConfigData: ReliquarySetExcelConfigDataType;
    TowerFloorExcelConfigData: TowerFloorExcelConfigDataType;
    TowerLevelExcelConfigData: TowerLevelExcelConfigDataType;
    TowerScheduleExcelConfigData: TowerScheduleExcelConfigDataType;
    WeaponCurveExcelConfigData: WeaponCurveExcelConfigDataType;
    WeaponExcelConfigData: WeaponExcelConfigDataType;
    WeaponPromoteExcelConfigData: WeaponPromoteExcelConfigDataType;
}

/**
 * Log level enumeration for the unified logging system
 */
declare enum LogLevel {
    NONE = 0,
    ERROR = 1,
    WARN = 2,
    INFO = 3,
    DEBUG = 4
}

/**
 * Type of value of object
 */
type ValueOf<T> = T[keyof T];
/**
 * Character upgrade plan interface
 */
interface CharacterUpgradePlan {
    /**
     * Character level upgrade: [current, target] or undefined if no change
     */
    characterLevel?: [number, number];
    /**
     * Skill level upgrades
     */
    skillLevels?: {
        /**
         * Normal attack level: [current, target] or undefined if no change
         */
        normalAttack?: [number, number];
        /**
         * Elemental skill level: [current, target] or undefined if no change
         */
        elementalSkill?: [number, number];
        /**
         * Elemental burst level: [current, target] or undefined if no change
         */
        elementalBurst?: [number, number];
    };
}
/**
 * Client option
 */
interface ClientOption {
    /**
     * Fetch option
     * @default
     * ```ts
     * {
     *   'user-agent': 'genshin-manager@x.x.x',
     * }
     * ```
     */
    fetchOption: RequestInit;
    /**
     * List of TextMaps to download when new assets are found.
     * @default
     * ```ts
     * ['EN','RU','VI','TH','PT','KR','JP','ID','FR','ES','DE','CHT','CHS']
     * ```
     */
    downloadLanguages: (keyof typeof TextMapLanguage)[];
    /**
     * default image base URL
     * @default 'https://gi.yatta.top/assets/UI'
     */
    defaultImageBaseURL: string;
    /**
     * default audio base URL
     * @default 'https://gi.yatta.top/assets/Audio'
     */
    defaultAudioBaseURL: string;
    /**
     * image base URL by regex
     * @default
     * ```ts
     * {
     *    'https://enka.network/ui': [
     *      /^UI_(AvatarIcon_Side|Costume)_/,
     *      /^UI_AvatarIcon_(.+)_Card$/,
     *      /^UI_AvatarIcon_(.+)_Circle/,
     *      /^UI_NameCardPic_(.+)_Alpha/,
     *      /^UI_EquipIcon_(.+)_Awaken/,
     *    ],
     *    'https://res.cloudinary.com/genshin/image/upload/sprites': [
     *      /^Eff_UI_Talent_/,
     *      /^UI_(TowerPic|TowerBlessing|GcgIcon|Gcg_Cardtable|Gcg_CardBack)_/,
     *    ],
     *    'https://gi.yatta.top/assets/UI/monster': [
     *      /^UI_(MonsterIcon|AnimalIcon)_/,
     *    ],
     *    'https://gi.yatta.top/assets/UI/gcg': [/^UI_Gcg_CardFace_/],
     *    'https://gi.yatta.top/assets/UI/reliquary': [/^UI_RelicIcon_/],
     *    'https://gi.yatta.top/assets/UI/namecard': [/^UI_NameCard/],
     *  },
     * ```
     */
    imageBaseURLByRegex: Record<string, RegExp[]>;
    /**
     * audio base url by regex
     * @default
     * ```ts
     * {}
     * ```
     */
    audioBaseURLByRegex: Record<string, RegExp[]>;
    /**
     * default language
     * @default 'EN'
     */
    defaultLanguage: keyof typeof TextMapLanguage;
    /**
     * log level for the application
     * @default LogLevel.NONE
     */
    logLevel?: LogLevel;
    /**
     * auto fetch latest assets by cron
     * @warn If this option is `undefined`, asset updates and initial setup are not executed
     * @default '0 0 0 * * 3' // minute hour day-of-month month day-of-week
     * @see https://crontab.guru/
     */
    autoFetchLatestAssetsByCron: string | undefined;
    /**
     * Automatically re-download the textMap if it has not been downloaded or if there is an error in the json format
     * @warn If `autoFetchLatestAssetsByCron` is `undefined`, this option will be ignored
     * @default true
     */
    autoFixTextMap: boolean;
    /**
     * Automatically fix the ExcelBin if it has not been downloaded or if there is an error in the json format
     * @warn If `autoFetchLatestAssetsByCron` is `undefined`, this option will be ignored
     * @default true
     */
    autoFixExcelBin: boolean;
    /**
     * auto cache image
     * @default true
     */
    autoCacheImage: boolean;
    /**
     * auto cache audio
     * @default true
     */
    autoCacheAudio: boolean;
    /**
     * asset cache folder path
     * @default node_modules/genshin-manager/cache
     */
    assetCacheFolderPath: string;
}
/**
 * Element Map for ExcelBinOut to Element
 */
declare const ElementKeys: {
    readonly Physical: "Phys";
    readonly Fire: "Pyro";
    readonly Electric: "Electro";
    readonly Ice: "Cryo";
    readonly Wind: "Anemo";
    readonly Water: "Hydro";
    readonly Rock: "Geo";
    readonly Grass: "Dendro";
};
/**
 * Element type
 */
type Element = ValueOf<typeof ElementKeys>;
/**
 * Character voice type
 */
type CVType = keyof Omit<typeof TextMapLanguage, 'RU' | 'VI' | 'TH' | 'PT' | 'ID' | 'FR' | 'ES' | 'DE' | 'CHT'>;
/**
 * FightProp Map
 * @remarks Numeric keys are necessary for runtime mapping from game data IDs
 */
declare const FightProps: {
    readonly 0: "FIGHT_PROP_NONE";
    readonly 1: "FIGHT_PROP_BASE_HP";
    readonly 2: "FIGHT_PROP_HP";
    readonly 3: "FIGHT_PROP_HP_PERCENT";
    readonly 4: "FIGHT_PROP_BASE_ATTACK";
    readonly 5: "FIGHT_PROP_ATTACK";
    readonly 6: "FIGHT_PROP_ATTACK_PERCENT";
    readonly 7: "FIGHT_PROP_BASE_DEFENSE";
    readonly 8: "FIGHT_PROP_DEFENSE";
    readonly 9: "FIGHT_PROP_DEFENSE_PERCENT";
    readonly 10: "FIGHT_PROP_BASE_SPEED";
    readonly 11: "FIGHT_PROP_SPEED_PERCENT";
    readonly 20: "FIGHT_PROP_CRITICAL";
    readonly 22: "FIGHT_PROP_CRITICAL_HURT";
    readonly 23: "FIGHT_PROP_CHARGE_EFFICIENCY";
    readonly 26: "FIGHT_PROP_HEAL_ADD";
    readonly 27: "FIGHT_PROP_HEALED_ADD";
    readonly 28: "FIGHT_PROP_ELEMENT_MASTERY";
    readonly 29: "FIGHT_PROP_PHYSICAL_SUB_HURT";
    readonly 30: "FIGHT_PROP_PHYSICAL_ADD_HURT";
    readonly 40: "FIGHT_PROP_FIRE_ADD_HURT";
    readonly 41: "FIGHT_PROP_ELEC_ADD_HURT";
    readonly 42: "FIGHT_PROP_WATER_ADD_HURT";
    readonly 43: "FIGHT_PROP_GRASS_ADD_HURT";
    readonly 44: "FIGHT_PROP_WIND_ADD_HURT";
    readonly 45: "FIGHT_PROP_ROCK_ADD_HURT";
    readonly 46: "FIGHT_PROP_ICE_ADD_HURT";
    readonly 50: "FIGHT_PROP_FIRE_SUB_HURT";
    readonly 51: "FIGHT_PROP_ELEC_SUB_HURT";
    readonly 52: "FIGHT_PROP_WATER_SUB_HURT";
    readonly 53: "FIGHT_PROP_GRASS_SUB_HURT";
    readonly 54: "FIGHT_PROP_WIND_SUB_HURT";
    readonly 55: "FIGHT_PROP_ROCK_SUB_HURT";
    readonly 56: "FIGHT_PROP_ICE_SUB_HURT";
    readonly 80: "FIGHT_PROP_SKILL_CD_MINUS_RATIO";
    readonly 81: "FIGHT_PROP_SHIELD_COST_MINUS_RATIO";
    readonly 1010: "FIGHT_PROP_CUR_HP";
    readonly 2000: "FIGHT_PROP_MAX_HP";
    readonly 2001: "FIGHT_PROP_CUR_ATTACK";
    readonly 2002: "FIGHT_PROP_CUR_DEFENSE";
    readonly 2003: "FIGHT_PROP_CUR_SPEED";
};
/**
 * FightProp type
 */
type FightPropType = ValueOf<typeof FightProps>;
/**
 * TextMap language type
 */
declare const TextMapLanguage: {
    readonly EN: readonly ["TextMapEN.json"];
    readonly RU: readonly ["TextMapRU_0.json", "TextMapRU_1.json"];
    readonly VI: readonly ["TextMapVI.json"];
    readonly TH: readonly ["TextMapTH_0.json", "TextMapTH_1.json"];
    readonly PT: readonly ["TextMapPT.json"];
    readonly KR: readonly ["TextMapKR.json"];
    readonly JP: readonly ["TextMapJP.json"];
    readonly ID: readonly ["TextMapID.json"];
    readonly FR: readonly ["TextMapFR.json"];
    readonly ES: readonly ["TextMapES.json"];
    readonly DE: readonly ["TextMapDE.json"];
    readonly CHT: readonly ["TextMapCHT.json"];
    readonly CHS: readonly ["TextMapCHS.json"];
};
/**
 * ExcelBin outputs
 */
declare const ExcelBinOutputs: {
    readonly AnimalCodexExcelConfigData: "AnimalCodexExcelConfigData.json";
    readonly AvatarCostumeExcelConfigData: "AvatarCostumeExcelConfigData.json";
    readonly AvatarCurveExcelConfigData: "AvatarCurveExcelConfigData.json";
    readonly AvatarExcelConfigData: "AvatarExcelConfigData.json";
    readonly AvatarPromoteExcelConfigData: "AvatarPromoteExcelConfigData.json";
    readonly AvatarSkillDepotExcelConfigData: "AvatarSkillDepotExcelConfigData.json";
    readonly AvatarSkillExcelConfigData: "AvatarSkillExcelConfigData.json";
    readonly AvatarTalentExcelConfigData: "AvatarTalentExcelConfigData.json";
    readonly DungeonEntryExcelConfigData: "DungeonEntryExcelConfigData.json";
    readonly DungeonLevelEntityConfigData: "DungeonLevelEntityConfigData.json";
    readonly EquipAffixExcelConfigData: "EquipAffixExcelConfigData.json";
    readonly FetterInfoExcelConfigData: "FetterInfoExcelConfigData.json";
    readonly FettersExcelConfigData: "FettersExcelConfigData.json";
    readonly FetterStoryExcelConfigData: "FetterStoryExcelConfigData.json";
    readonly ManualTextMapConfigData: "ManualTextMapConfigData.json";
    readonly MaterialExcelConfigData: "MaterialExcelConfigData.json";
    readonly MonsterCurveExcelConfigData: "MonsterCurveExcelConfigData.json";
    readonly MonsterDescribeExcelConfigData: "MonsterDescribeExcelConfigData.json";
    readonly MonsterExcelConfigData: "MonsterExcelConfigData.json";
    readonly ProudSkillExcelConfigData: "ProudSkillExcelConfigData.json";
    readonly ProfilePictureExcelConfigData: "ProfilePictureExcelConfigData.json";
    readonly ReliquaryAffixExcelConfigData: "ReliquaryAffixExcelConfigData.json";
    readonly ReliquaryExcelConfigData: "ReliquaryExcelConfigData.json";
    readonly ReliquaryLevelExcelConfigData: "ReliquaryLevelExcelConfigData.json";
    readonly ReliquaryMainPropExcelConfigData: "ReliquaryMainPropExcelConfigData.json";
    readonly ReliquarySetExcelConfigData: "ReliquarySetExcelConfigData.json";
    readonly TowerFloorExcelConfigData: "TowerFloorExcelConfigData.json";
    readonly TowerLevelExcelConfigData: "TowerLevelExcelConfigData.json";
    readonly TowerScheduleExcelConfigData: "TowerScheduleExcelConfigData.json";
    readonly WeaponCurveExcelConfigData: "WeaponCurveExcelConfigData.json";
    readonly WeaponExcelConfigData: "WeaponExcelConfigData.json";
    readonly WeaponPromoteExcelConfigData: "WeaponPromoteExcelConfigData.json";
};
/**
 * Cache structure type mapping for processed game data
 */
interface CacheStructureMap {
    /**
     * Animal codex entries mapped by describe ID
     */
    AnimalCodexExcelConfigData: Record<string, MasterFileMap['AnimalCodexExcelConfigData'] | undefined>;
    /**
     * Avatar costume data mapped by skin ID
     */
    AvatarCostumeExcelConfigData: Record<string, MasterFileMap['AvatarCostumeExcelConfigData'] | undefined>;
    /**
     * Avatar stat curve data indexed by type then level
     */
    AvatarCurveExcelConfigData: Record<string, Record<number, number>>;
    /**
     * Avatar base data mapped by character ID
     */
    AvatarExcelConfigData: Record<string, MasterFileMap['AvatarExcelConfigData'] | undefined>;
    /**
     * Avatar ascension data nested by promote ID and level
     */
    AvatarPromoteExcelConfigData: Record<string, Record<string, MasterFileMap['AvatarPromoteExcelConfigData'] | undefined>>;
    /**
     * Avatar skill depot configurations mapped by ID
     */
    AvatarSkillDepotExcelConfigData: Record<string, MasterFileMap['AvatarSkillDepotExcelConfigData'] | undefined>;
    /**
     * Avatar skill definitions mapped by skill ID
     */
    AvatarSkillExcelConfigData: Record<string, MasterFileMap['AvatarSkillExcelConfigData'] | undefined>;
    /**
     * Avatar talent data mapped by talent ID
     */
    AvatarTalentExcelConfigData: Record<string, MasterFileMap['AvatarTalentExcelConfigData'] | undefined>;
    /**
     * Dungeon entry configurations mapped by ID
     */
    DungeonEntryExcelConfigData: Record<string, MasterFileMap['DungeonEntryExcelConfigData'] | undefined>;
    /**
     * Dungeon level entity data mapped by client ID
     */
    DungeonLevelEntityConfigData: Record<string, MasterFileMap['DungeonLevelEntityConfigData'] | undefined>;
    /**
     * Equipment affix data mapped by affix ID
     */
    EquipAffixExcelConfigData: Record<string, MasterFileMap['EquipAffixExcelConfigData'] | undefined>;
    /**
     * Character fetter info mapped by avatar ID
     */
    FetterInfoExcelConfigData: Record<string, MasterFileMap['FetterInfoExcelConfigData'] | undefined>;
    /**
     * Fetter configuration data mapped by fetter ID
     */
    FettersExcelConfigData: Record<string, MasterFileMap['FettersExcelConfigData'] | undefined>;
    /**
     * Character story data mapped by fetter ID
     */
    FetterStoryExcelConfigData: Record<string, MasterFileMap['FetterStoryExcelConfigData'] | undefined>;
    /**
     * Manual text map entries indexed by text map ID
     */
    ManualTextMapConfigData: Record<string, MasterFileMap['ManualTextMapConfigData'] | undefined>;
    /**
     * Material item data mapped by material ID
     */
    MaterialExcelConfigData: Record<string, MasterFileMap['MaterialExcelConfigData'] | undefined>;
    /**
     * Monster stat curve data indexed by type then level
     */
    MonsterCurveExcelConfigData: Record<string, Record<number, number>>;
    /**
     * Monster description data mapped by ID
     */
    MonsterDescribeExcelConfigData: Record<string, MasterFileMap['MonsterDescribeExcelConfigData'] | undefined>;
    /**
     * Monster configuration data mapped by monster ID
     */
    MonsterExcelConfigData: Record<string, MasterFileMap['MonsterExcelConfigData'] | undefined>;
    /**
     * Profile picture data mapped by picture ID
     */
    ProfilePictureExcelConfigData: Record<string, MasterFileMap['ProfilePictureExcelConfigData'] | undefined>;
    /**
     * Skill enhancement data nested by group ID and skill level
     */
    ProudSkillExcelConfigData: Record<string, Record<number, MasterFileMap['ProudSkillExcelConfigData'] | undefined>>;
    /**
     * Artifact affix data mapped by affix ID
     */
    ReliquaryAffixExcelConfigData: Record<string, MasterFileMap['ReliquaryAffixExcelConfigData'] | undefined>;
    /**
     * Artifact base data mapped by artifact ID
     */
    ReliquaryExcelConfigData: Record<string, MasterFileMap['ReliquaryExcelConfigData'] | undefined>;
    /**
     * Artifact stat growth data indexed by type, rank, and level
     */
    ReliquaryLevelExcelConfigData: Record<string, Record<number, Record<number, number>>>;
    /**
     * Artifact main stat data mapped by prop ID
     */
    ReliquaryMainPropExcelConfigData: Record<string, MasterFileMap['ReliquaryMainPropExcelConfigData'] | undefined>;
    /**
     * Artifact set bonus data mapped by set ID
     */
    ReliquarySetExcelConfigData: Record<string, MasterFileMap['ReliquarySetExcelConfigData'] | undefined>;
    /**
     * Spiral Abyss floor data mapped by floor ID
     */
    TowerFloorExcelConfigData: Record<string, MasterFileMap['TowerFloorExcelConfigData'] | undefined>;
    /**
     * Spiral Abyss level data mapped by level ID
     */
    TowerLevelExcelConfigData: Record<string, MasterFileMap['TowerLevelExcelConfigData'] | undefined>;
    /**
     * Spiral Abyss schedule data mapped by schedule ID
     */
    TowerScheduleExcelConfigData: Record<string, MasterFileMap['TowerScheduleExcelConfigData'] | undefined>;
    /**
     * Weapon stat curve data indexed by type then level
     */
    WeaponCurveExcelConfigData: Record<string, Record<number, number>>;
    /**
     * Weapon base data mapped by weapon ID
     */
    WeaponExcelConfigData: Record<string, MasterFileMap['WeaponExcelConfigData'] | undefined>;
    /**
     * Weapon ascension data nested by promote ID and level
     */
    WeaponPromoteExcelConfigData: Record<string, Record<string, MasterFileMap['WeaponPromoteExcelConfigData'] | undefined>>;
}

/**
 * Type for event map.
 */
type EventMap<T> = Record<keyof T, unknown[]> | DefaultEventMap;
/**
 * Default event map type
 */
type DefaultEventMap = [never];
/**
 * Key type for event handling
 */
type Key<K, E, T> = T extends DefaultEventMap ? string | symbol : (K | E) | keyof T;
/**
 * Rest arguments type
 */
type AnyRest = [...args: unknown[]];
/**
 * Arguments type for events
 */
type Args<K, T> = T extends DefaultEventMap ? AnyRest : K extends keyof T ? T[K] : never;
/**
 * Event listener type
 */
type Listener<K, T, R> = T extends DefaultEventMap ? (...args: unknown[]) => R : K extends keyof T ? T[K] extends unknown[] ? (...args: T[K]) => R : never : never;
/**
 * Type for event listener.
 */
type Listener1<K, T> = Listener<K, T, Awaitable<void>>;
/**
 * Type for values that can be awaited
 */
type Awaitable<Value> = PromiseLike<Value> | Value;
/**
 * Class for supporting asynchronous event listeners.
 * @see EventEmitter
 */
declare abstract class PromiseEventEmitter<T extends EventMap<T>, E extends keyof T> {
    private readonly emitter;
    /**
     * Create a PromiseEventEmitter.
     * @example
     * ```ts
     * class MyEmitter extends PromiseEventEmitter<{test: [string]}, 'test'> {}
     * const emitter = new MyEmitter()
     * emitter.on('test', async (data) => console.log(data))
     * ```
     */
    constructor();
    /**
     * Adds a **one-time**`listener` function for the event named `eventName`. The next time `eventName` is triggered, this listener is removed and then invoked.
     * @param eventName the name of the event.
     * @param listener the callback function. (supports async)
     * @see EventEmitter.once()
     */
    once<K>(eventName: Key<K, E, T>, listener: Listener1<K, T>): this;
    /**
     * Adds the `listener` function to the end of the listeners array for the event named `eventName`.
     * No checks are made to see if the `listener` has already been added.
     * Multiple calls passing the same combination of `eventName`and `listener` will result in the `listener` being added, and called, multiple times.
     * @param eventName the name of the event.
     * @param listener the callback function. (supports async)
     * @see EventEmitter.on()
     */
    on<K>(eventName: Key<K, E, T>, listener: Listener1<K, T>): this;
    /**
     * Alias for `emitter.on(eventName, listener)`.
     * @param eventName the name of the event.
     * @param listener the callback function. (supports async)
     * @see EventEmitter.addListener()
     */
    addListener<K>(eventName: Key<K, E, T>, listener: Listener1<K, T>): this;
    /**
     * Alias for `emitter.removeListener()`.
     * @param eventName the name of the event.
     * @param listener the callback function. (supports async)
     * @see EventEmitter.off()
     */
    off<K>(eventName: Key<K, E, T>, listener: Listener1<K, T>): this;
    /**
     * Removes the specified `listener` from the listener array for the event named`eventName`.
     * @param eventName the name of the event.
     * @param listener the callback function. (supports async)
     * @see EventEmitter.removeListener()
     */
    removeListener<K>(eventName: Key<K, E, T>, listener: Listener1<K, T>): this;
    /**
     * Removes all listeners, or those of the specified `eventName`.
     * @param event the name of the event.
     * @see EventEmitter.removeAllListeners()
     */
    removeAllListeners<K>(event?: Key<K, E, T>): this;
    /**
     * Synchronously calls each of the listeners registered for the event named`eventName`, in the order they were registered, passing the supplied arguments to each.
     * Returns `true` if the event had listeners, `false` otherwise.
     * @param eventName the name of the event.
     * @param args arguments to pass to the listeners.
     * @see EventEmitter.emit()
     */
    protected emit<K>(eventName: Key<K, E, T>, ...args: Args<K, T>): boolean;
}

interface AssetCacheManagerEventMap {
    BEGIN_UPDATE_CACHE: [version: string];
    END_UPDATE_CACHE: [version: string];
    BEGIN_UPDATE_ASSETS: [version: string];
    END_UPDATE_ASSETS: [version: string];
}
/**
 * Class for managing cached assets
 * @abstract
 */
declare abstract class AssetCacheManager<T extends EventMap<T>, E extends keyof T> extends PromiseEventEmitter<T, E> {
    /**
     * Cached text map
     * @deprecated This property is deprecated because it is used to pass data to each class
     * @key Text hash
     * @value Text
     */
    static readonly _cachedTextMap: Map<number, string>;
    /**
     * Asset event emitter
     * @deprecated This property is deprecated because it is used to pass data to each class
     */
    protected static readonly _assetEventEmitter: EventEmitter<AssetCacheManagerEventMap>;
    private static readonly GIT_REMOTE_API_URL;
    private static readonly GIT_REMOTE_RAW_BASE_URL;
    /**
     * Cached text map
     * @key ExcelBinOutput name
     * @value Cached excel bin output
     */
    private static cachedExcelBinOutput;
    private static option;
    private static nowCommitId;
    private static commitFilePath;
    private static excelBinOutputFolderPath;
    private static textMapFolderPath;
    private static textHashes;
    private static useExcelBinOutputKeys;
    /**
     * Create a AssetCacheManager
     * @param option client option
     */
    constructor(option: ClientOption);
    /**
     * Assets game version text
     * @returns assets game version text or undefined
     */
    protected static get gameVersion(): string | undefined;
    /**
     * Create ExcelBinOutput Keys to cache
     * @returns all ExcelBinOutput Keys
     */
    private static get excelBinOutputAllKeys();
    /**
     * Download json file from URL and write to downloadFilePath
     * Prevents file conflicts through concurrent access control
     * @param url URL
     * @param downloadFilePath download file path
     */
    static downloadJsonFile(url: string, downloadFilePath: string): Promise<void>;
    /**
     * Add ExcelBinOutput Key from Class Prototype to AssetCacheManager
     * @deprecated This method is deprecated because it is used to pass data to each class
     * @param classPrototype class prototype
     */
    static _addExcelBinOutputKeyFromClassPrototype(classPrototype: unknown): void;
    /**
     * Get Json from cached excel bin output
     * @deprecated This method is deprecated because it is used to pass data to each class
     * @param key excelBinOutput name
     * @param id ID of character, etc
     * @returns JSON
     */
    static _getJsonFromCachedExcelBinOutput<T extends keyof typeof ExcelBinOutputs>(key: T, id: string | number): NonNullable<CacheStructureMap[T][string]>;
    /**
     * Get cached excel bin output by name
     * @deprecated This method is deprecated because it is used to pass data to each class
     * @param key excelBinOutput name
     * @returns cached excel bin output
     */
    static _getCachedExcelBinOutputByName<T extends keyof typeof ExcelBinOutputs>(key: T): CacheStructureMap[T];
    /**
     * Check if cached excel bin output exists by name
     * @deprecated This method is deprecated because it is used to pass data to each class
     * @param key excelBinOutput name
     * @returns cached excel bin output exists
     */
    static _hasCachedExcelBinOutputByName(key: keyof typeof ExcelBinOutputs): boolean;
    /**
     * Check if cached excel bin output exists by ID
     * @deprecated This method is deprecated because it is used to pass data to each class
     * @param key excelBinOutput name
     * @param id ID of character, etc
     * @returns cached excel bin output exists
     */
    static _hasCachedExcelBinOutputById(key: keyof typeof ExcelBinOutputs, id: string | number): boolean;
    /**
     * Search ID in CachedExcelBinOutput by text
     * @deprecated This method is deprecated because it is used to pass data to each class
     * @param key excelBinOutput name
     * @param text text
     * @returns IDs
     */
    static _searchIdInExcelBinOutByText(key: keyof typeof ExcelBinOutputs, text: string): string[];
    /**
     * Change cached languages
     * @param language country code
     * @returns true if an error occurs
     */
    protected static setTextMapToCache(language: keyof typeof TextMapLanguage): Promise<boolean>;
    /**
     * Update cache
     * @example
     * ```ts
     * await Client.updateCache()
     * ```
     */
    protected static updateCache(): Promise<void>;
    /**
     * Set excel bin output to cache
     * @param keys excelBinOutput names
     * @returns true if an error occurs
     */
    protected static setExcelBinOutputToCache(keys: Set<keyof typeof ExcelBinOutputs>): Promise<boolean>;
    /**
     * Process and cache a single Excel bin output entry
     * @param fileName - Excel bin output file name
     * @param jsonObjectArray - Raw JSON data array
     */
    private static processCacheEntry;
    /**
     * Check gitlab for new commits
     * @returns new assets version text or undefined
     */
    private static checkGitUpdate;
    /**
     * Create TextHashes to cache
     */
    private static createTextHashes;
    /**
     * Re download text map
     * @param language country code
     */
    private static reDownloadTextMap;
    /**
     * Re download all excel bin output
     */
    private static reDownloadAllExcelBinOutput;
    /**
     * Fetch asset folder from gitlab
     * @param folderPath folder path
     * @param files file names
     * @param isRetry is retry
     */
    private static fetchAssetFolder;
    /**
     * Internal download process executed within file lock
     * @param url URL
     * @param downloadFilePath download file path
     */
    private static downloadJsonFileInternal;
    /**
     * Type guard for GitLabAPIResponse
     * @param value value to check
     * @returns true if value is GitLabAPIResponse
     */
    private static isGitLabAPIResponse;
    /**
     * Retry operation until it succeeds (returns false)
     * @param operation async operation that returns true on error (requires retry)
     */
    private static retryUntilSuccess;
}

/**
 * Client events
 * @see {@link Client}
 */
declare enum ClientEvents {
    /**
     * When the cache update starts, fires
     * @event BEGIN_UPDATE_CACHE
     * @listener
     * | param | type | description |
     * | --- | --- | --- |
     * | version | string | Game version of assets to cache |
     */
    BEGIN_UPDATE_CACHE = "BEGIN_UPDATE_CACHE",
    /**
     * When the cache update ends, fires
     * @event END_UPDATE_CACHE
     * @listener
     * | param | type | description |
     * | --- | --- | --- |
     * | version | string | Game version of assets to cache |
     */
    END_UPDATE_CACHE = "END_UPDATE_CACHE",
    /**
     * When the assets update starts, fires
     * @event BEGIN_UPDATE_ASSETS
     * @listener
     * | param | type | description |
     * | --- | --- | --- |
     * | version | string | Game version of new assets |
     */
    BEGIN_UPDATE_ASSETS = "BEGIN_UPDATE_ASSETS",
    /**
     * When the assets update ends, fires
     * @event END_UPDATE_ASSETS
     * @listener
     * | param | type | description |
     * | --- | --- | --- |
     * | version | string | Game version of new assets |
     */
    END_UPDATE_ASSETS = "END_UPDATE_ASSETS"
}
interface ClientEventMap {
    BEGIN_UPDATE_CACHE: [version: string];
    END_UPDATE_CACHE: [version: string];
    BEGIN_UPDATE_ASSETS: [version: string];
    END_UPDATE_ASSETS: [version: string];
}
/**
 * Main client for the Genshin Manager library
 * @description This is the main body of `Genshin-Manager` where cache information is stored
 */
declare class Client extends AssetCacheManager<ClientEventMap, ClientEvents> {
    /**
     * Default option
     */
    private static readonly defaultOption;
    readonly option: ClientOption;
    /**
     * Create a Client
     * @param option client option
     * @example
     * ```ts
     * const client = new Client({
     *   defaultLanguage: 'EN',
     *   logLevel: LogLevel.INFO,
     *   autoCacheImage: true
     * })
     * ```
     */
    constructor(option?: Partial<ClientOption>);
    /**
     * Cached game version
     * @returns cached game version
     * @example `5.1.0`
     */
    get gameVersion(): string | undefined;
    /**
     * Change cached languages
     * @param language country code
     * @example
     * ```ts
     * const client = new Client()
     * await client.deploy()
     * await client.changeLanguage('JP')
     * ```
     */
    changeLanguage(language: keyof typeof TextMapLanguage): Promise<void>;
    /**
     * Deploy assets to cache & Update assets
     * @example
     * ```ts
     * const client = new Client()
     * await client.deploy()
     * ```
     */
    deploy(): Promise<void>;
}

/**
 * Class for compiling information about image
 */
declare class ImageAssets {
    /**
     * Image base URL of mihoyo
     */
    private static readonly IMAGE_BASE_URL_MIHOYO;
    /**
     * Image types
     */
    private static readonly imageTypes;
    /**
     * Fetch option
     */
    private static fetchOption;
    /**
     * Image base URL by regex
     */
    private static imageBaseURLByRegex;
    /**
     * Default image base URL
     */
    private static defaultImageBaseURL;
    /**
     * Whether to cache the image
     */
    private static autoCacheImage;
    /**
     * Image folder path
     */
    private static imageFolderPath;
    /**
     * Image name
     */
    readonly name: string;
    /**
     * Image base URL
     */
    readonly imageBaseURL: string;
    /**
     * Image URL
     */
    readonly url: string;
    /**
     * Image type
     */
    readonly imageType: string | null;
    /**
     * Image URL of mihoyo
     */
    readonly mihoyoURL: string;
    /**
     * Classes for handling images
     * @param name image name
     * @param url image URL(Basically, no need to specify)
     */
    constructor(name: string, url?: string);
    /**
     * Create a ImageAssets instance from the image URL
     * @param url image URL
     * @returns ImageAssets instance
     */
    static fromURL(url: string): ImageAssets;
    /**
     * Classes for handling images
     * @param option client option
     */
    static deploy(option: ClientOption): void;
    /**
     * Fetch image buffer
     * @returns image buffer
     */
    fetchBuffer(): Promise<Buffer>;
    /**
     * Fetch image stream
     * @param highWaterMark highWaterMark
     * @returns image stream
     */
    fetchStream(highWaterMark?: number): Promise<fs.ReadStream>;
    /**
     * Check if the PNG file is corrupted
     * @warning Limited corruption detection - only validates PNG signature and IEND chunk. May not detect all corruption types.
     * @param filePath file path
     * @returns is PNG file corrupted
     */
    private isPNGCorrupted;
}

/**
 * Represents a statistical property with type, name, and value information
 */
declare class StatProperty {
    /**
     * Stat type
     */
    readonly type: FightPropType;
    /**
     * Stat name
     */
    readonly name: string;
    /**
     * Whether the stat is a percent value
     */
    readonly isPercent: boolean;
    /**
     * Stat value
     */
    readonly value: number;
    /**
     * Create a StatProperty
     * @param type fight prop type
     * @param value value of the stat
     * @example
     * ```ts
     * const hpStat = new StatProperty('FIGHT_PROP_HP', 15552)
     * console.log(hpStat.name)
     * console.log(hpStat.valueText)
     * ```
     */
    constructor(type: FightPropType, value: number);
    /**
     * Get value text
     * @returns value text
     */
    get valueText(): string;
    /**
     * Get multiplied value
     * @returns multiplied value
     */
    get multipliedValue(): number;
    /**
     * IEEE 754 rounding method
     * @param v value
     * @returns rounded value
     */
    private cleanUp;
}

interface ArtifactAffixAppendProp {
    id: number;
    type: FightPropType;
    value: number;
}
/**
 * Represents a game artifact with stats and set bonuses
 */
declare class Artifact {
    /**
     * Max level map of artifacts by rarity
     */
    private static readonly maxLevelMap;
    /**
     * IDs of set bonuses that can be activated with one artifact
     */
    private static readonly oneSetBonusIds;
    /**
     * IDs of set bonuses that cannot be obtained
     */
    private static readonly blackSetIds;
    /**
     * IDs of artifacts that cannot be obtained
     */
    private static readonly blackArtifactIds;
    /**
     * Artifact ID
     */
    readonly id: number;
    /**
     * Artifact level
     */
    readonly level: number;
    /**
     * Artifact type
     */
    readonly type: EquipType;
    /**
     * Artifact name
     */
    readonly name: string;
    /**
     * Artifact description
     */
    readonly description: string;
    /**
     * Artifact set ID
     */
    readonly setId: number | undefined;
    /**
     * Artifact set name
     */
    readonly setName: string | undefined;
    /**
     * Artifact set description (index:1 = 1pc, 2 = 2pc , 4 = 4pc)
     */
    readonly setDescriptions: Record<number, string | undefined>;
    /**
     * Artifact rarity
     */
    readonly rarity: number;
    /**
     * Main stat
     */
    readonly mainStat: StatProperty;
    /**
     * Artifact sub stats
     */
    readonly subStats: StatProperty[];
    /**
     * Artifact sub stats
     */
    readonly appendProps: ArtifactAffixAppendProp[];
    /**
     * Artifact icon
     */
    readonly icon: ImageAssets;
    /**
     * Create a Artifact
     * @param artifactId artifact ID
     * @param mainPropId main stat ID from ReliquaryMainPropExcelConfigData.json. Default: 10001
     * @param level artifact level (0-20). Default: 0
     * @param appendPropIds artifact sub stat IDs
     * @example
     * ```ts
     * const artifact = new Artifact(81101, 10001, 20, [501221, 501231])
     * console.log(artifact.name)
     * console.log(artifact.mainStat.value)
     * ```
     */
    constructor(artifactId: number, mainPropId?: number, level?: number, appendPropIds?: number[]);
    /**
     * Get all artifact IDs
     * @returns all artifact IDs
     * @example
     * ```ts
     * const allIds = Artifact.allArtifactIds
     * console.log(allIds.length)
     * ```
     */
    static get allArtifactIds(): number[];
    /**
     * Get max level by artifact ID
     * @param artifactId artifact ID
     * @returns max level
     * @example
     * ```ts
     * const maxLevel = Artifact.getMaxLevelByArtifactId(81101)
     * console.log(maxLevel) // 20 for 5-star artifacts
     * ```
     */
    static getMaxLevelByArtifactId(artifactId: number): number;
    /**
     * Get sub stat properties from appendProp IDs
     * @param appendPropIds artifact sub stat IDs
     * @returns sub stat properties
     */
    private getSubStatProperties;
}

/**
 * Manages character constellation upgrades and unlockable passive abilities
 */
declare class CharacterConstellation {
    /**
     * Constellation ID
     */
    readonly id: number;
    /**
     * Constellation name
     */
    readonly name: string;
    /**
     * Constellation description
     */
    readonly description: string;
    /**
     * Constellation icon
     */
    readonly icon: ImageAssets;
    /**
     * Whether the constellation is locked
     */
    readonly locked: boolean;
    /**
     * Create a Constellation
     * @param constellationId constellation ID
     * @param locked whether the constellation is locked
     */
    constructor(constellationId: number, locked?: boolean);
    /**
     * Get all constellation IDs
     * @returns all constellation IDs
     */
    static get allConstellationIds(): number[];
    /**
     * Get constellation IDs by character ID
     * @param characterId character ID
     * @param skillDepotId skill depot ID
     * @returns constellation IDs
     */
    static getConstellationIdsByCharacterId(characterId: number, skillDepotId?: number): number[];
}

/**
 * Represents character outfit skins and alternative visual appearances
 */
declare class CharacterCostume {
    /**
     * Costume ID
     */
    readonly id: number;
    /**
     * Character ID
     */
    readonly characterId: number;
    /**
     * Costume name
     */
    readonly name: string;
    /**
     * Costume description
     */
    readonly description: string;
    /**
     * Costume quality
     */
    readonly quality: number;
    /**
     * Costume side icon
     */
    readonly sideIcon: ImageAssets;
    /**
     * Costume icon
     */
    readonly icon: ImageAssets;
    /**
     * Costume art
     */
    readonly art: ImageAssets;
    /**
     * Costume card
     */
    readonly card: ImageAssets;
    /**
     * Create a Costume
     * @param costumeId costume ID
     */
    constructor(costumeId: number);
    /**
     * Get all costume IDs
     * @returns all costume IDs
     */
    static get allCostumeIds(): number[];
}

/**
 * Contains character skill information including attacks, burst, and elemental abilities
 */
declare class CharacterSkill {
    /**
     * Skill ID
     */
    readonly id: number;
    /**
     * Skill name
     */
    readonly name: string;
    /**
     * Skill description
     */
    readonly description: string;
    /**
     * Skill icon
     */
    readonly icon: ImageAssets;
    /**
     * level + extraLevel
     */
    readonly level: number;
    /**
     * Levels increased by constellation
     */
    readonly extraLevel: number;
    /**
     * Skill param descriptions
     * @returns (`${description}|${param}`)[]
     */
    readonly paramDescriptions: string[];
    /**
     * Create a Skill
     * @param skillId skill ID
     * @param level skill level (1-15). Default: 1
     * @param extraLevel levels increased by constellation (0 or 3). Default: 0
     */
    constructor(skillId: number, level?: number, extraLevel?: number);
    /**
     * Get all skill IDs
     * @returns all skill IDs
     */
    static get allSkillIds(): number[];
    /**
     * Get skill order by character ID
     * @param characterId character ID
     * @param skillDepotId skill depot ID
     * @returns skill order
     */
    static getSkillOrderByCharacterId(characterId: number, skillDepotId?: number): number[];
}

/**
 * Manages character combat statistics and calculated property values
 */
declare class CharacterStatusManager {
    readonly healthBase: StatProperty;
    readonly healthFlat: StatProperty;
    readonly healthPercent: StatProperty;
    readonly attackBase: StatProperty;
    readonly attackFlat: StatProperty;
    readonly attackPercent: StatProperty;
    readonly defenseBase: StatProperty;
    readonly defenseFlat: StatProperty;
    readonly defensePercent: StatProperty;
    readonly speedBase: StatProperty;
    readonly speedPercent: StatProperty;
    readonly critRate: StatProperty;
    readonly critDamage: StatProperty;
    readonly chargeEfficiency: StatProperty;
    readonly healAdd: StatProperty;
    readonly healedAdd: StatProperty;
    readonly elementMastery: StatProperty;
    readonly physicalRes: StatProperty;
    readonly physicalDamage: StatProperty;
    readonly pyroDamage: StatProperty;
    readonly electroDamage: StatProperty;
    readonly hydroDamage: StatProperty;
    readonly dendroDamage: StatProperty;
    readonly anemoDamage: StatProperty;
    readonly geoDamage: StatProperty;
    readonly cryoDamage: StatProperty;
    readonly pyroRes: StatProperty;
    readonly electroRes: StatProperty;
    readonly hydroRes: StatProperty;
    readonly dendroRes: StatProperty;
    readonly anemoRes: StatProperty;
    readonly geoRes: StatProperty;
    readonly cryoRes: StatProperty;
    readonly sortedDamageBonus: StatProperty[];
    readonly pyroEnergyCost: number;
    readonly electroEnergyCost: number;
    readonly hydroEnergyCost: number;
    readonly dendroEnergyCost: number;
    readonly anemoEnergyCost: number;
    readonly cryoEnergyCost: number;
    readonly geoEnergyCost: number;
    readonly energyCost: number;
    readonly cooldownReduction: StatProperty;
    readonly shieldStrength: StatProperty;
    readonly currentPyroEnergy: number;
    readonly currentElectroEnergy: number;
    readonly currentHydroEnergy: number;
    readonly currentDendroEnergy: number;
    readonly currentAnemoEnergy: number;
    readonly currentCryoEnergy: number;
    readonly currentGeoEnergy: number;
    readonly currentEnergy: number;
    readonly currentHealth: StatProperty;
    readonly maxHealth: StatProperty;
    readonly attack: StatProperty;
    readonly defense: StatProperty;
    readonly speed: StatProperty;
    readonly statProperties: StatProperty[];
    private readonly fightPropData;
    /**
     * Create a CharacterStatusManager
     * @param fightPropData fightPropMap from EnkaNetwork and other sources
     */
    constructor(fightPropData: Record<number, number | undefined>);
    /**
     * Get StatProperty from fightPropData
     * @param id fightProp ID
     * @param defaultValue default value if fightPropData[ID] is undefined
     * @returns StatProperty
     */
    private getStatProperty;
}

/**
 * Manages artifact set effects and bonuses that activate when wearing multiple pieces
 */
declare class SetBonus {
    /**
     * IDs of set bonuses that can be activated with one artifact
     */
    private static readonly oneSetBonusIds;
    /**
     * Set bonus that can be triggered by a single artifact
     */
    readonly oneSetBonus: Artifact[];
    /**
     * Set bonus that can be triggered by two artifacts
     */
    readonly twoSetBonus: Artifact[];
    /**
     * Set bonus that can be triggered by four artifacts
     */
    readonly fourSetBonus: Artifact[];
    /**
     * Create a SetBonus
     * @param artifacts artifacts equipped by the character
     */
    constructor(artifacts: Artifact[]);
}

/**
 * Contains weapon information including stats, refinement, and enhancement data
 */
declare class WeaponInfo {
    /**
     * Black weapon IDs
     */
    private static readonly blackWeaponIds;
    /**
     * Weapon name
     */
    readonly name: string;
    /**
     * Weapon description
     */
    readonly description: string;
    /**
     * Weapon type
     */
    readonly type: WeaponType;
    /**
     * Weapon skill name
     */
    readonly skillName: string | undefined;
    /**
     * Weapon skill description
     */
    readonly skillDescription: string | undefined;
    /**
     * Weapon ID
     */
    readonly id: number;
    /**
     * Weapon level
     */
    readonly level: number;
    /**
     * Weapon max level
     */
    readonly maxLevel: number;
    /**
     * Weapon promote level
     */
    readonly promoteLevel: number;
    /**
     * Weapon is ascended
     */
    readonly isAscended: boolean;
    /**
     * Weapon refinement rank
     */
    readonly refinementRank: number;
    /**
     * Weapon rarity
     */
    readonly rarity: number;
    /**
     * Weapon stats
     */
    readonly stats: StatProperty[];
    /**
     * Whether the weapon is awakened
     */
    readonly isAwaken: boolean;
    /**
     * Weapon icon
     */
    readonly icon: ImageAssets;
    /**
     * Create a WeaponInfo
     * @param weaponId weapon ID
     * @param level weapon level (1-90). Default: 1
     * @param isAscended weapon is ascended. Default: true
     * @param refinementRank weapon refinement rank (1-5). Default: 1
     */
    constructor(weaponId: number, level?: number, isAscended?: boolean, refinementRank?: number);
    /**
     * Get all weapon IDs
     * @returns all weapon IDs
     */
    static get allWeaponIds(): number[];
    /**
     * Get weapon ID by name
     * @param name weapon name
     * @returns weapon ID
     */
    static getWeaponIdByName(name: string): number[];
    /**
     * Get stat value by json
     * @param weaponPropJson weapon property json
     * @param addValue add value
     * @returns stat value
     */
    private getStatPropertyByJson;
}

/**
 * Enka API ShowAvatarInfo type
 */
interface APIShowAvatarInfo {
    /**
     * Character ID
     */
    avatarId: number;
    /**
     * Character level
     */
    level: number;
    /**
     * Character costume ID
     */
    costumeId?: number;
    /**
     * Character element ID
     */
    energyType?: number;
    /**
     * Character constellation Count
     */
    talentLevel?: number;
}
/**
 * Enka API PlayerInfo type
 */
interface APIPlayerInfo {
    /**
     * Player Nickname
     */
    nickname?: string;
    /**
     * Player Adventure Level
     */
    level: number;
    /**
     * Profile Signature
     */
    signature?: string;
    /**
     * Player World Level
     */
    worldLevel?: number;
    /**
     * Profile NameCard ID
     */
    nameCardId: number;
    /**
     * Number of Completed Achievements
     */
    finishAchievementNum?: number;
    /**
     * Abyss Floor
     */
    towerFloorIndex?: number;
    /**
     * Abyss Floor's Chamber
     */
    towerLevelIndex?: number;
    /**
     * Abyss Star Index
     */
    towerStarIndex?: number;
    /**
     * List of Character IDs and Levels
     */
    showAvatarInfoList?: APIShowAvatarInfo[];
    /**
     * List of NameCard IDs
     */
    showNameCardIdList?: number[];
    /**
     * Profile Picture
     */
    profilePicture?: APIProfilePicture;
    /**
     * Show Avatar Talent
     */
    isShowAvatarTalent?: boolean;
    /**
     * Number of characters with max friendship level
     */
    fetterCount?: number;
    /**
     * Imaginarium Theater Act Index
     */
    theaterActIndex?: number;
    /**
     * Number of supporting cast members for Imaginarium Theater
     */
    theaterModeIndex?: number;
    /**
     * Imaginarium Theater Star Index
     */
    theaterStarIndex?: number;
}
/**
 * Enka API ProfilePicture type
 */
interface APIProfilePicture {
    /**
     * Character ID
     */
    avatarId?: number;
    /**
     * Profile Picture ID
     */
    id?: number;
    /**
     * Costume ID
     */
    costumeId?: number;
}
/**
 * Enka API PropMap type
 */
interface APIPropMap {
    /**
     * Property value
     */
    val?: string;
}
/**
 * Enka API Reliquary type
 */
interface APIReliquary {
    /**
     * Level
     */
    level: number;
    /**
     * Main Property ID
     */
    mainPropId: number;
    /**
     * Append Property ID List
     */
    appendPropIdList?: number[];
}
/**
 * Enka API Weapon type
 */
interface APIWeapon {
    /**
     * Level
     */
    level: number;
    /**
     * Refinement Level
     */
    promoteLevel?: number;
    /**
     * Affix Map
     */
    affixMap?: Record<string, number>;
}
/**
 * Enka API ReliquaryEquip type
 */
interface APIReliquaryEquip {
    /**
     * Reliquary ID
     */
    itemId: number;
    /**
     * Artifact Base Info
     */
    reliquary: APIReliquary;
}
/**
 * Enka API WeaponEquip type
 */
interface APIWeaponEquip {
    /**
     * Weapon ID
     */
    itemId: number;
    /**
     * Weapon Base Info
     */
    weapon: APIWeapon;
}
/**
 * Enka API AvatarInfo type
 */
interface APIAvatarInfo {
    /**
     * Character ID
     */
    avatarId: number;
    /**
     * Character costume ID
     */
    costumeId?: number;
    /**
     * Character Info Properties List
     */
    propMap: Record<number, APIPropMap>;
    /**
     * List of Constellation IDs
     * @warn There is no data if 0 Constellation
     */
    talentIdList?: number[];
    /**
     * Map of Character's Combat Properties
     */
    fightPropMap: Record<number, number>;
    /**
     * Character Skill Set ID
     */
    skillDepotId: number;
    /**
     * Map of Skill Levels
     */
    skillLevelMap: Record<string, number>;
    /**
     * Map of Skill Extra Levels
     */
    proudSkillExtraLevelMap?: Record<string, number>;
    /**
     * List of Equipments: Weapon, Artifacts
     */
    equipList: (APIReliquaryEquip | APIWeaponEquip)[];
    /**
     * fetterInfo
     */
    fetterInfo: {
        /**
         * Character Friendship Level
         */
        expLevel: number;
    };
}
/**
 * Enka API Owner type
 */
interface APIOwner {
    /**
     * Hash
     */
    hash?: string;
    /**
     * User Name
     */
    username: string;
    /**
     * Profile
     */
    profile: APIProfile;
    /**
     * Enka Network Account ID
     */
    id: number;
}
/**
 * Enka API PlayerDetail type
 */
interface APIProfile {
    /**
     * biography
     */
    bio: string;
    /**
     * level
     */
    level: number;
    /**
     * signup state
     */
    signup_state: number;
    /**
     * profile picture
     */
    avatar: string | null;
    /**
     * profile picture #2?
     */
    image_url: string;
}

/**
 * Enka API GameAccount type
 */
interface APIGameAccount {
    /**
     * UID
     */
    uid: number;
    /**
     * Is the UID public
     */
    uid_public: boolean;
    /**
     * Is the UID public
     */
    public: boolean;
    /**
     * Is the live preview public
     */
    live_public: boolean;
    /**
     * is the account verified
     */
    verified: boolean;
    /**
     * Player Info
     */
    player_info: APIPlayerInfo;
    /**
     * GameAccount Hash
     */
    hash: string;
    /**
     * region
     */
    region: string;
    /**
     * order
     */
    order: number;
    /**
     * avatar order
     */
    avatar_order: Record<string, number>;
    /**
     * hoyo type (0: GI 1:HSR)
     */
    hoyo_type: number;
}
/**
 * Enka API Build type
 */
interface APIBuild {
    /**
     * Build ID
     */
    id: number;
    /**
     * Build Name
     */
    name: string;
    /**
     * Character ID
     */
    avatar_id: string;
    /**
     * Avatar Info
     */
    avatar_data: APIAvatarInfo;
    /**
     * order
     */
    order: number;
    /**
     * is the live preview
     */
    live: boolean;
    /**
     * Build Settings
     */
    settings: APIBuildSettings;
    /**
     * is the public
     */
    public: boolean;
    /**
     * image URL
     */
    image: null | string;
    /**
     * hoyo type (0: GI 1:HSR)
     */
    hoyo_type: number;
}
/**
 * Enka API Build Settings type
 */
interface APIBuildSettings {
    /**
     * build description
     */
    caption?: string;
    /**
     * custom art source
     */
    artSource?: string;
    /**
     * honkard width
     */
    honkardWidth?: number;
    /**
     * Is Adaptive Color
     */
    adaptiveColor?: boolean;
}

/**
 * EnkaStatusTypes
 * @description This is a parse of status.enka.network/api/now
 */
interface APIEnkaStatus {
    /**
     * now Date string
     */
    readonly now: string;
    /**
     * HSR Stat
     */
    readonly hsr: APIEnkaStat;
    /**
     * GI Stat
     */
    readonly gi: APIEnkaStat;
    /**
     * GG Stat
     */
    readonly gg: APIEnkaStat;
    /**
     * Pingu Stat
     */
    readonly pingu: APIEnkaPingu;
}
/**
 * EnkaRegion
 */
type APIEnkaRegion = 'euro' | 'usa' | 'asia' | 'cht' | 'china' | 'bilibili';
/**
 * EnkaStat
 */
interface APIEnkaStat {
    /**
     * response time (ms)
     */
    time: Partial<Record<APIEnkaRegion, number>>;
    /**
     * ping (ms)
     */
    ping: Partial<Record<APIEnkaRegion, number>>;
    /**
     * request capacity (req/min)
     */
    nodes: Partial<Record<APIEnkaRegion, number>>;
    /**
     * underruns (fails)
     */
    underruns: Partial<Record<APIEnkaRegion, string>>;
}
/**
 * EnkaPingu
 */
interface APIEnkaPingu {
    /**
     * CDN
     */
    cdn: APIEnkaPing;
    /**
     * Main
     */
    main: APIEnkaPing;
    /**
     * API
     */
    api: APIEnkaPing;
    /**
     * Fox
     */
    fox: APIEnkaPing;
}
/**
 * EnkaPing
 */
interface APIEnkaPing {
    /**
     * response time (ms)
     */
    ms: number;
    /**
     * status code
     */
    status: number;
}

/**
 * Represents detailed character data retrieved from the EnkaNetwork API
 */
declare class CharacterDetail {
    /**
     * Character ID
     */
    readonly id: number;
    /**
     * Character default costume ID
     */
    readonly defaultCostumeId: number;
    /**
     * Character Depot ID
     */
    readonly depotId: number;
    /**
     * Character name
     */
    readonly name: string;
    /**
     * Character element
     */
    readonly element: Element | undefined;
    /**
     * Character rarity
     */
    readonly rarity: number;
    /**
     * Character body type
     */
    readonly bodyType: BodyType;
    /**
     * Character weapon type
     */
    readonly weaponType: WeaponType;
    /**
     * Character costume
     */
    readonly costume: CharacterCostume;
    /**
     * Character level
     */
    readonly level: number;
    /**
     * Character max level
     */
    readonly maxLevel: number;
    /**
     * Character level XP
     */
    readonly levelXp: number;
    /**
     * Character promote level (ascension)
     */
    readonly promoteLevel: number;
    /**
     * Character constellations
     * @warning This value shows the actual constellation level regardless of the player's privacy settings.
     * It is not affected by the `isShowCharacterPreviewConstellation` setting.
     * @see {@link PlayerDetail.isShowCharacterPreviewConstellation}
     */
    readonly constellations: CharacterConstellation[];
    /**
     * Character skills
     */
    readonly skills: CharacterSkill[];
    /**
     * Character combat status
     */
    readonly combatStatus: CharacterStatusManager;
    /**
     * Weapon equipped by Character
     */
    readonly weapon: WeaponInfo;
    /**
     * Artifacts equipped by Character
     */
    readonly artifacts: Artifact[];
    /**
     * Character friendship level
     */
    readonly friendShipLevel: number;
    /**
     * Character set bonus
     */
    readonly setBonus: SetBonus;
    /**
     * Data from EnkaNetwork
     */
    readonly data: APIAvatarInfo;
    /**
     * Create a CharacterDetail
     * @param data data from EnkaNetwork
     */
    constructor(data: APIAvatarInfo);
}

/**
 * Represents an EnkaNetwork user account with access credentials
 */
declare class EnkaAccount {
    /**
     * Account ID
     */
    readonly id: number;
    /**
     * Account name
     */
    readonly username: string;
    /**
     * Account biography
     */
    readonly bio: string;
    /**
     * Account level
     */
    readonly level: number;
    /**
     * Account signup state
     */
    readonly signupState: number;
    /**
     * Account avatar URL
     */
    readonly avatar?: string;
    /**
     * Account image URL
     */
    readonly imageURL: string;
    /**
     * Enkanetwork URL
     */
    readonly url: string;
    /**
     * Data from EnkaNetwork
     */
    readonly data: APIOwner;
    /**
     * Create a EnkaAccount
     * @param ownerData ownerData from EnkaNetwork
     * @param enkaBaseURL URL of enka.network
     */
    constructor(ownerData: APIOwner, enkaBaseURL: string);
}

/**
 * Represents a character build configuration from EnkaNetwork showcases
 */
declare class EnkaBuild {
    /**
     * Build ID
     */
    readonly id: number;
    /**
     * Build name
     */
    readonly name: string;
    /**
     * Build description
     */
    readonly description: string;
    /**
     * Build custom art source URL
     */
    readonly customArtURL?: string;
    /**
     * Character Detail
     */
    readonly characterDetail: CharacterDetail;
    /**
     * Is the public
     */
    readonly isPublic: boolean;
    /**
     * Is the live preview
     */
    readonly isLive: boolean;
    /**
     * Is adaptive color
     */
    readonly isAdaptiveColor: boolean;
    /**
     * honkard width
     */
    readonly honkardWidth: number;
    /**
     * EnkaNetwork URL
     */
    readonly url: string;
    /**
     * Data from EnkaNetwork
     */
    readonly data: APIBuild;
    /**
     * Create a EnkaBuild
     * @param data data from EnkaNetwork
     * @param genshinAccountURL URL of enka.network game account
     */
    constructor(data: APIBuild, genshinAccountURL: string);
}

/**
 * Provides summary character information for display from EnkaNetwork data
 */
declare class CharacterPreview extends CharacterCostume {
    /**
     * Character level
     */
    readonly level: number;
    /**
     * Character element
     * @warning May be undefined if character data hasn't been updated since version 5.0+ or if element data is missing from API response.
     */
    readonly element: Element | undefined;
    /**
     * Character constellation level (0-6)
     * @warning Returns 0 when player has disabled constellation visibility in privacy settings.
     * @see {@link PlayerDetail.isShowCharacterPreviewConstellation}
     */
    readonly collectionLevel: number | undefined;
    /**
     * Data from EnkaNetwork
     */
    readonly data: APIShowAvatarInfo;
    /**
     * Create a character preview
     * @param data data from EnkaNetwork
     */
    constructor(data: APIShowAvatarInfo);
}

/**
 * Represents a game material or resource used for character and weapon enhancement
 */
declare class Material {
    /**
     * Material ID
     */
    readonly id: number;
    /**
     * Material name
     */
    readonly name: string;
    /**
     * Material description
     */
    readonly description: string;
    /**
     * Material icon
     */
    readonly icon: ImageAssets;
    /**
     * Material pictures
     */
    readonly pictures: ImageAssets[];
    /**
     * Material type
     */
    readonly itemType: ItemType$2;
    /**
     * Material type
     */
    readonly materialType?: MaterialType$1;
    /**
     * Create a Material
     * @param materialId material ID
     * @example
     * ```ts
     * const material = new Material(104001)
     * console.log(material.name)
     * console.log(material.description)
     * ```
     */
    constructor(materialId: number);
    /**
     * Get all material IDs
     * @returns all material IDs
     * @example
     * ```ts
     * const allIds = Material.allMaterialIds
     * console.log(allIds.length)
     * ```
     */
    static get allMaterialIds(): number[];
    /**
     * Get material ID by name
     * @param name material name
     * @returns material ID
     * @example
     * ```ts
     * const ids = Material.getMaterialIdByName('Mystic Enhancement Ore')
     * console.log(ids)
     * ```
     */
    static getMaterialIdByName(name: string): number[];
}

/**
 * Manages character avatar images and profile picture assets
 */
declare class ProfilePicture {
    /**
     * Profile picture ID
     */
    readonly id: number;
    /**
     * Profile picture type
     */
    readonly type: Type$2;
    /**
     * Avatar ID
     * @description Exists only if type is `PROFILE_PICTURE_UNLOCK_BY_AVATAR`
     */
    readonly characterId?: number;
    /**
     * Costume ID
     * @description Exists only if type is `PROFILE_PICTURE_UNLOCK_BY_COSTUME`
     */
    readonly costumeId?: number;
    /**
     * Material ID
     * @description Exists only if type is `PROFILE_PICTURE_UNLOCK_BY_ITEM`
     */
    readonly materialId?: number;
    /**
     * Quest ID
     * @description Exists only if type is `PROFILE_PICTURE_UNLOCK_BY_PARENT_QUEST`
     */
    readonly questId?: number;
    /**
     * Profile picture icon
     */
    readonly icon: ImageAssets;
    /**
     * Create a ProfilePicture
     * @param profilePictureId profile picture ID
     */
    constructor(profilePictureId: number);
    /**
     * Get all profile picture IDs
     * @returns profile picture IDs
     */
    static get allProfilePictureIds(): number[];
    /**
     * Find profile picture ID by info ID
     * @param unlockParam costume ID or Character ID or Material ID or Quest ID
     * @returns profile picture ID
     */
    static findProfilePictureIdByUnlockParam(unlockParam: number): number | undefined;
}

/**
 * Contains player profile information and game progress from EnkaNetwork
 */
declare class PlayerDetail {
    /**
     * Player Nickname
     */
    readonly nickname: string;
    /**
     * Player Adventure Rank
     */
    readonly level: number;
    /**
     * Player signature
     */
    readonly signature: string;
    /**
     * Player World Level
     */
    readonly worldLevel: number;
    /**
     * Profile NameCard ID
     */
    readonly nameCard: Material;
    /**
     * Number of Completed Achievements
     */
    readonly finishAchievementNum: number;
    /**
     * Abyss Floor
     */
    readonly towerFloorIndex: number;
    /**
     * Abyss Floor's Chamber
     */
    readonly towerLevelIndex: number;
    /**
     * Abyss Star Index
     */
    readonly towerStarIndex: number;
    /**
     * Character previews
     */
    readonly characterPreviews: CharacterPreview[];
    /**
     * Show NameCards
     */
    readonly showNameCards: Material[];
    /**
     * Player Profile Picture
     */
    readonly profilePicture: ProfilePicture;
    /**
     * Number of characters with max friendship level
     */
    readonly maxFriendshipCharactersCount: number;
    /**
     * Imaginarium Theater Act Index
     */
    readonly theaterActIndex: number;
    /**
     * Imaginarium Theater Mode Index (5:easy, 6:hard...)
     */
    readonly theaterModeIndex: number;
    /**
     * Imaginarium Theater Star Index
     */
    readonly theaterStarIndex: number;
    /**
     * Show Character Preview Constellation
     */
    readonly isShowCharacterPreviewConstellation: boolean;
    /**
     * Data from EnkaNetwork
     */
    readonly data: APIPlayerInfo;
    /**
     * Create a PlayerDetail
     * @param data data from EnkaNetwork
     */
    constructor(data: APIPlayerInfo);
    /**
     * Initialize character previews from API data
     * @param data API player info
     * @returns array of character previews
     */
    private initializeCharacterPreviews;
    /**
     * Initialize show name cards from API data
     * @param data API player info
     * @returns array of materials
     */
    private initializeShowNameCards;
    /**
     * Create profile picture from API data
     * @param data API player info
     * @returns profile picture instance
     */
    private createProfilePicture;
}

/**
 * Represents a Genshin Impact account with associated game data and builds
 */
declare class GenshinAccount {
    /**
     * UID
     */
    readonly uid: number;
    /**
     * Hash
     */
    readonly hash: string;
    /**
     * Region
     */
    readonly region: string;
    /**
     * Is the UID public
     */
    readonly uidPublic: boolean;
    /**
     * Is the live preview public
     */
    readonly livePublic: boolean;
    /**
     * Is the account verified
     */
    readonly verified: boolean;
    /**
     * PlayerDetail
     */
    readonly playerDetail: PlayerDetail;
    /**
     * Builds
     */
    readonly builds: EnkaBuild[][];
    /**
     * EnkaNetwork URL
     */
    readonly url: string;
    /**
     * Data from EnkaNetwork
     */
    readonly data: APIGameAccount;
    /**
     * Create a GenshinAccount
     * @param gameAccountData data from EnkaNetwork
     * @param buildDatas data from EnkaNetwork
     * @param username username of EnkaNetwork
     * @param enkaBaseURL URL of enka.network
     */
    constructor(gameAccountData: APIGameAccount, buildDatas: Record<string, APIBuild[]>, username: string, enkaBaseURL: string);
}

/**
 * Cached EnkaData type
 */
interface EnkaData {
    /**
     * UID
     */
    readonly uid: number;
    /**
     * Player detail
     */
    readonly playerDetail: PlayerDetail;
    /**
     * Character details
     */
    readonly characterDetails: CharacterDetail[];
    /**
     * UID owner Enka Account
     */
    readonly owner?: EnkaAccount;
    /**
     * NextShowCaseDate
     */
    readonly nextShowCaseDate: Date;
    /**
     * EnkaNetwork URL
     */
    readonly url: string;
}
/**
 * EnkaManager events
 * @see {@link EnkaManager}
 */
declare enum EnkaManagerEvents {
    /**
     * When new data is added to the cache, fires
     * @event GET_NEW_ENKA_DATA
     * @listener
     * | param | type | description |
     * | --- | --- | --- |
     * | data | {@link EnkaData} | New data added to the cache |
     */
    GET_NEW_ENKA_DATA = "GET_NEW_ENKA_DATA"
}
interface EnkaManagerEventMap {
    GET_NEW_ENKA_DATA: [data: EnkaData];
}
/**
 * Class for fetching EnkaData from enka.network
 */
declare class EnkaManager extends PromiseEventEmitter<EnkaManagerEventMap, EnkaManagerEvents> {
    /**
     * URL of enka.network
     */
    private static readonly ENKA_BASE_URL;
    /**
     * URL of status.enka.network
     */
    private static readonly ENKA_STATUS_BASE_URL;
    /**
     * Default fetch option
     */
    private static readonly defaultFetchOption;
    /**
     * Cache of EnkaData
     * @key UID
     * @value Cached EnkaData
     */
    private readonly cache;
    /**
     * Fetch All from enka.network
     * @description The data fetched by this method is stored as a temporary cache.
     *    The storage period depends on ttl.
     * @param uid UID
     * @param fetchOption fetch option
     * @returns enka data
     * @example
     * ```ts
     * const enkaManager = new EnkaManager()
     * const data = await enkaManager.fetchAll(123456789)
     * console.log(data.playerDetail.nickname)
     * ```
     */
    fetchAll(uid: number, fetchOption?: RequestInit): Promise<EnkaData>;
    /**
     * Fetch PlayerDetail from enka.network
     * @description The data fetched by this method is stored as a temporary cache.
     *    The storage period depends on ttl.
     * @param uid UID
     * @param fetchOption fetch option
     * @returns player detail
     * @example
     * ```ts
     * const enkaManager = new EnkaManager()
     * const playerDetail = await enkaManager.fetchPlayerDetail(123456789)
     * console.log(playerDetail.nickname)
     * ```
     */
    fetchPlayerDetail(uid: number, fetchOption?: RequestInit): Promise<PlayerDetail>;
    /**
     * Clear cache over nextShowCaseDate
     */
    clearCacheOverNextShowCaseDate(): void;
    /**
     * Fetch EnkaAccount from enka.network
     * @description Data fetched by this method is not stored as a temporary cache.
     * @param username enka account username
     * @param fetchOption fetch option
     * @returns enka account
     * @example
     * ```ts
     * const enkaManager = new EnkaManager()
     * const account = await enkaManager.fetchEnkaAccount('username')
     * console.log(account.nickname)
     * ```
     */
    fetchEnkaAccount(username: string, fetchOption?: RequestInit): Promise<EnkaAccount>;
    /**
     * Fetch GenshinAccounts from enka.network
     * @description Data fetched by this method is not stored as a temporary cache.
     * @param username enka account username
     * @param fetchOption fetch option
     * @returns genshin accounts
     * @example
     * ```ts
     * const enkaManager = new EnkaManager()
     * const accounts = await enkaManager.fetchGenshinAccounts('username')
     * console.log(accounts[0].uid)
     * ```
     */
    fetchGenshinAccounts(username: string, fetchOption?: RequestInit): Promise<GenshinAccount[]>;
    /**
     * Fetch Status from 1 hour ago to now
     * @param fetchOption fetch option
     * @returns status from 1 hour ago to now
     */
    fetchAllStatus(fetchOption?: RequestInit): Promise<Record<string, APIEnkaStatus>>;
    /**
     * Fetch now Status
     * @param fetchOption fetch option
     * @returns now status
     */
    fetchNowStatus(fetchOption?: RequestInit): Promise<APIEnkaStatus>;
    /**
     * Fetch UIDEndPoint from URL
     * @param uid UID
     * @param url URL
     * @param fetchOption fetch option
     * @returns enka data
     */
    private fetchUID;
}

/**
 * Time difference per region (hour)
 */
declare const TimeZonesPerRegion: {
    readonly cn_gf01: 8;
    readonly cn_qd01: 8;
    readonly os_usa: -5;
    readonly os_euro: 1;
    readonly os_asia: 8;
    readonly os_cht: 8;
};
/**
 * Region type
 */
type Region = keyof typeof TimeZonesPerRegion;
/**
 * URL params for getAnn
 */
interface URLParams {
    /**
     * Game ID
     * @default 'hk4e'
     */
    game: string;
    /**
     * Game biz
     * @default 'hk4e_global'
     */
    game_biz: string;
    /**
     * Language
     * @default 'en'
     */
    lang: keyof typeof NoticeLanguage;
    /**
     * Auth app ID
     * @default 'announcement'
     */
    auth_appid: string;
    /**
     * Bundle ID
     * @default 'hk4e_global'
     */
    bundle_id: string;
    /**
     * Channel ID
     * @default '1'
     */
    channel_id: string;
    /**
     * Level
     * @default '60'
     */
    level: string;
    /**
     * Platform
     * @default 'pc'
     */
    platform: string;
    /**
     * Region
     * @default 'os_asia'
     */
    region: Region;
    /**
     * SDK presentation style
     * @default 'fullscreen'
     */
    sdk_presentation_style: string;
    /**
     * SDK screen transparent
     * @default 'true'
     */
    sdk_screen_transparent: string;
    /**
     * UID
     * @default '888888888'
     */
    uid: string;
}
/**
 * language code map for getAnn
 */
declare const NoticeLanguage: {
    readonly en: "en-us";
    readonly ru: "ru-ru";
    readonly vi: "vi-vn";
    readonly th: "th-th";
    readonly pt: "pt-br";
    readonly ko: "ko-kr";
    readonly ja: "ja-jp";
    readonly id: "id-id";
    readonly fr: "fr-fr";
    readonly es: "es-es";
    readonly de: "de-de";
    readonly 'zh-tw': "zh-tw";
    readonly 'zh-cn': "zh-cn";
};

/**
 * Data of ContentData
 */
interface ContentList {
    /**
     * Ann ID
     */
    ann_id: number;
    /**
     * Ann title
     */
    title: string;
    /**
     * Ann subtitle
     */
    subtitle: string;
    /**
     * Ann banner URL
     */
    banner: string;
    /**
     * Ann content
     */
    content: string;
    /**
     * Ann language
     */
    lang: ValueOf<typeof NoticeLanguage>;
}
/**
 * Data of TabList
 */
interface DataList {
    /**
     * Ann ID
     */
    ann_id: number;
    /**
     * Ann title
     */
    title: string;
    /**
     * Ann subtitle
     */
    subtitle: string;
    /**
     * Ann banner URL
     */
    banner: string;
    /**
     * Ann content
     * @remark none
     */
    content: string;
    /**
     * Ann type label (type_list.mi18n_name)
     */
    type_label: string;
    /**
     * Ann Tab label (1:! 2:flag 3:star)
     */
    tag_label: string;
    /**
     * Ann Tab icon URL
     */
    tag_icon: string;
    /**
     * Ann login alert (1:yes 0:no)
     * @remark unknown. 1 only?
     */
    login_alert: number;
    /**
     * Ann language
     */
    lang: ValueOf<typeof NoticeLanguage>;
    /**
     * Ann start time (Always fluctuating)
     */
    start_time: string;
    /**
     * Ann end time (Always fluctuating)
     */
    end_time: string;
    /**
     * Ann type (type_list.id)
     */
    type: number;
    /**
     * Ann remind (1:yes 0:no)
     * @remark unknown. 0 only?
     */
    remind: number;
    /**
     * Ann alert (1:yes 0:no)
     * @remark unknown. 0 only?
     */
    alert: number;
    /**
     * Ann Tab start time(unknown)
     */
    tag_start_time: string;
    /**
     * Ann Tab end time(unknown)
     */
    tag_end_time: string;
    /**
     * Ann remind version
     * @remark fix version?
     */
    remind_ver: number;
    /**
     * Ann has content
     * @remark unknown. true only?
     */
    has_content: boolean;
    /**
     * Ann extra remind
     * @remark unknown
     */
    extra_remind: number;
}

type CheerioAPI = ReturnType<typeof cheerio.load>;
/**
 * Class for compiling in-game announcement information
 */
declare class Notice {
    /**
     * Date and time format options
     */
    private static dateTimeFormatOptions;
    /**
     * Notice ID
     */
    readonly id: number;
    /**
     * Notice title
     */
    readonly title: string;
    /**
     * Notice subtitle
     */
    readonly subtitle: string;
    /**
     * Notice banner
     */
    readonly banner: ImageAssets;
    /**
     * Notice content DOM manipulation interface (Cheerio/jQuery-like)
     * @warning Raw HTML content may include table tags that should be filtered for text extraction
     */
    readonly $: CheerioAPI;
    /**
     * Notice type (1:event or 2:important)
     */
    readonly type: number;
    /**
     * Notice type label (event or important)
     */
    readonly typeLabel: string;
    /**
     * Notice tag (1:! 2:star 3:flag)
     */
    readonly tag: number;
    /**
     * Notice tag icon
     */
    readonly tagIcon: ImageAssets;
    /**
     * Event start time
     * @description If `undefined`, use getEventDuration()
     */
    readonly eventStart: Date | undefined;
    /**
     * Event end time
     * @description If `undefined`, use getEventDuration()
     */
    readonly eventEnd: Date | undefined;
    /**
     * Reward image
     */
    readonly rewardImg: ImageAssets | undefined;
    /**
     * Notice remind version
     */
    readonly version: number;
    /**
     * Notice language
     */
    readonly lang: ValueOf<typeof NoticeLanguage>;
    /**
     * Notice region
     */
    readonly region: Region;
    private readonly _en$;
    /**
     * Create a Notice
     * @param annList annList
     * @param annContent annContent
     * @param enAnnContent annContent(lang=en)
     * @param region region
     * @example
     * ```ts
     * const notice = new Notice(annListData, annContentData, enAnnContentData, 'os_asia')
     * console.log(notice.title)
     * console.log(notice.subtitle)
     * ```
     */
    constructor(annList: DataList, annContent: ContentList, enAnnContent: ContentList, region: Region);
    /**
     * Get the text of the notice
     * @warning This method does not exclude table tags
     * @returns notice all text
     */
    get text(): string;
    /**
     * Get the duration of the event
     * @returns event duration
     */
    get eventDuration(): string | undefined;
    private get durationTitleElement();
    /**
     * Convert t tag to region time
     * @warning t tags work fine when inserted with text() content because the original is \&gt; or \&lt;.
     * @param text text
     * @returns converted text
     */
    private convertLocalDate;
}

/**
 * NoticeManager events
 * @see {@link NoticeManager}
 */
declare enum NoticeManagerEvents {
    /**
     * When a notice is added, fires
     * @event ADD_NOTICE
     * @listener
     * | param | type | description |
     * | --- | --- | --- |
     * | notice | {@link Notice} | Added Notice |
     */
    ADD_NOTICE = "ADD_NOTICE",
    /**
     * When a notice is removed, fires
     * @event REMOVE_NOTICE
     * @listener
     * | param | type | description |
     * | --- | --- | --- |
     * | notice | {@link Notice} | Removed Notice |
     */
    REMOVE_NOTICE = "REMOVE_NOTICE"
}
interface NoticeManagerEventMap {
    ADD_NOTICE: [notice: Notice];
    REMOVE_NOTICE: [notice: Notice];
}
/**
 * Class for fetching notices from mihoyo
 */
declare class NoticeManager extends PromiseEventEmitter<NoticeManagerEventMap, NoticeManagerEvents> {
    /**
     * Minimum update interval(ms)
     * @default 1 minute
     */
    private static readonly MIN_UPDATE_INTERVAL;
    /**
     * URL of getAnnContent
     */
    private static readonly GIT_CONTENT_URL;
    /**
     * URL of getAnnList
     */
    private static readonly GIT_LIST_URL;
    /**
     * Default URL params
     */
    private static readonly defaultURLParams;
    /**
     * Language of notices
     */
    readonly language: keyof typeof NoticeLanguage;
    /**
     * Update interval(ms)
     */
    readonly updateInterval: number | undefined;
    /**
     * Notices
     * @key Notice ID
     * @value Notice
     */
    readonly notices: Map<number, Notice>;
    /**
     * URL params
     */
    private readonly urlParams;
    /**
     * Create a NoticeManager
     * @param language language of notices
     * @param updateInterval update interval(ms) Min: 1 minute
     * @param urlParams URL params
     * @example
     * ```ts
     * const noticeManager = new NoticeManager('en', 60000)
     * await noticeManager.update()
     * console.log(noticeManager.notices.size)
     * ```
     */
    constructor(language: keyof typeof NoticeLanguage, updateInterval?: number, urlParams?: Partial<URLParams>);
    /**
     * Update notices
     */
    update(): Promise<void>;
    /**
     * Get AnnContent
     * @param lang language of notices
     * @returns annContent
     */
    private getAnnContent;
    /**
     * Get AnnList
     * @returns annList
     */
    private getAnnList;
    /**
     * Get Ann
     * @param urlText URL
     * @param lang language of notices
     * @returns ann
     */
    private _getAnn;
}

/**
 * Class for compiling information about audio
 */
declare class AudioAssets {
    /**
     * Audio base URL of mihoyo
     */
    private static readonly AUDIO_BASE_URL_MIHOYO;
    /**
     * Fetch option
     */
    private static fetchOption;
    /**
     * Audio base URL by regex
     */
    private static audioBaseURLByRegex;
    /**
     * Default audio base URL
     */
    private static defaultAudioBaseURL;
    /**
     * Whether to cache the audio
     */
    private static autoCacheAudio;
    /**
     * Audio folder path
     */
    private static audioFolderPath;
    /**
     * Audio name
     */
    readonly name: string;
    /**
     * Audio base URL
     */
    readonly audioBaseURL: string;
    /**
     * Audio URL
     */
    readonly url: string;
    /**
     * Audio cv
     */
    readonly cv?: CVType;
    /**
     * Character ID
     */
    readonly characterId?: number;
    /**
     * Audio URL of mihoyo
     */
    readonly mihoyoURL: string;
    /**
     * Classes for handling audios
     * @param name audio name
     * @param cv audio cv
     * @param characterId character ID
     */
    constructor(name: string, cv?: CVType, characterId?: number);
    /**
     * Classes for handling audios
     * @param option client option
     */
    static deploy(option: ClientOption): void;
    /**
     * Fetch audio buffer
     * @returns audio buffer
     */
    fetchBuffer(): Promise<Buffer>;
    /**
     * Fetch audio stream
     * @param highWaterMark highWaterMark
     * @returns audio stream
     */
    fetchStream(highWaterMark?: number): Promise<fs.ReadStream>;
    /**
     * Check if the OGG file is corrupted
     * @warning Limited corruption detection - only validates the final OggS header. May not catch all types of file corruption.
     * @param filePath file path
     * @returns is OGG file corrupted
     */
    private isOGGCorrupted;
}

/**
 * Represents a character's passive skill with unlocked bonuses and effects
 */
declare class CharacterInherentSkill {
    /**
     * Inherent Skill ID
     */
    readonly id: number;
    /**
     * Inherent Skill name
     */
    readonly name: string;
    /**
     * Inherent Skill description
     */
    readonly description: string;
    /**
     * Inherent Skill icon
     */
    readonly icon: ImageAssets;
    /**
     * Inherent Skill addProps
     */
    readonly addProps: StatProperty[];
    /**
     * Create a Inherent Skill
     * @param inherentSkillId inherent skill ID
     */
    constructor(inherentSkillId: number);
    /**
     * Get all inherent skill IDs
     * @returns all inherent skill IDs
     */
    static get allInherentSkillIds(): number[];
    /**
     * Get inherent skill order by character ID
     * @param characterId character ID
     * @param skillDepotId skill depot ID
     * @returns inherent skill order
     */
    static getInherentSkillOrderByCharacterId(characterId: number, skillDepotId?: number): number[];
}

/**
 * Represents character profile information including basic details and associations
 */
declare class CharacterProfile {
    /**
     * Character ID
     */
    readonly characterId: number;
    /**
     * Fetter ID
     */
    readonly fetterId: number;
    /**
     * Birth date
     */
    readonly birthDate: Date | undefined;
    /**
     * Affiliation
     */
    readonly native: string;
    /**
     * Character Vision
     */
    readonly vision: string;
    /**
     * Character Constellation
     */
    readonly constellation: string;
    /**
     * Profile Title
     */
    readonly title: string;
    /**
     * Profile Detail
     */
    readonly detail: string;
    /**
     * Association
     */
    readonly assocType: FetterInfoExcelConfigDataType['avatarAssocType'];
    /**
     * Character Voice
     */
    readonly cv: Record<CVType, string>;
    /**
     * Create a Profile
     * @param characterId character ID
     */
    constructor(characterId: number);
    /**
     * Get all character IDs
     * @returns all character IDs
     */
    static get allCharacterIds(): number[];
}

/**
 * Contains character background story content and narrative elements
 */
declare class CharacterStory {
    /**
     * fetter ID in the story
     */
    readonly fetterId: number;
    /**
     * Character ID
     */
    readonly characterId: number;
    /**
     * Story Title
     */
    readonly title: string;
    /**
     * Story Content
     */
    readonly content: string;
    /**
     * Story Tips
     */
    readonly tips: string[];
    /**
     * Create a CharacterStories
     * @param fetterId fetter ID in the story
     */
    constructor(fetterId: number);
    /**
     * Get all Fetter IDs in the story
     * @returns all Fetter IDs in the story
     */
    static get allFetterIds(): number[];
    /**
     * Get all Fetter IDs in the character's story
     * @param characterId character ID
     * @returns all fetter IDs in the character's story
     */
    static getAllFetterIdsByCharacterId(characterId: number): number[];
}

/**
 * Handles character voice lines and audio assets in different languages
 */
declare class CharacterVoice {
    /**
     * fetter ID in the voice
     */
    readonly fetterId: number;
    /**
     * CV language
     */
    readonly cv: CVType;
    /**
     * Costume IDs to hide this
     */
    readonly hideCostumeList: number[];
    /**
     * Costume IDs to show this
     */
    readonly showCostumeList: number[];
    /**
     * Character ID
     */
    readonly characterId: number;
    /**
     * Voice Type
     * @description 1: non-Fighting 2: Fighting
     */
    readonly type: number;
    /**
     * Voice Title
     */
    readonly title: string;
    /**
     * Voice Content
     */
    readonly content: string;
    /**
     * Voice Tips
     */
    readonly tips: string[];
    /**
     * Voice Audio
     */
    readonly audio: AudioAssets;
    /**
     * Create a CharacterVoice
     * @param fetterId fetter ID in the voice
     * @param cv CV language
     */
    constructor(fetterId: number, cv: CVType);
    /**
     * Get all Fetter IDs in the voice
     * @returns all Fetter IDs in the voice
     */
    static get allFetterIds(): number[];
    /**
     * Get all Fetter IDs in the character's voice
     * @param characterId character ID
     * @returns all Fetter IDs in the character's voice
     */
    static getAllFetterIdsByCharacterId(characterId: number): number[];
}

/**
 * Unified character class providing comprehensive access to all character data
 */
declare class Character {
    /**
     * Character ID
     */
    readonly id: number;
    /**
     * Character level
     */
    readonly level: number;
    /**
     * Character is ascended
     */
    readonly isAscended: boolean;
    /**
     * Constellation level (0-6)
     */
    readonly constellationLevel: number;
    /**
     * Character info instance
     */
    private readonly info;
    /**
     * Character base stats instance
     */
    private readonly baseStats;
    /**
     * Character ascension instance
     */
    private readonly ascension;
    /**
     * Create a Character
     * @param characterId character ID
     * @param level character level (1-90). Default: 1
     * @param isAscended character is ascended (true or false). Default: false
     * @param constellationLevel constellation level (0-6). Default: 0
     * @param skillDepotId skill depot ID (for travelers). Optional
     */
    constructor(characterId: number, level?: number, isAscended?: boolean, constellationLevel?: number, skillDepotId?: number);
    /**
     * Get all character IDs
     * @returns all character IDs
     */
    static get allCharacterIds(): number[];
    /**
     * Character name
     */
    get name(): string;
    /**
     * Character max level
     */
    get maxLevel(): number;
    /**
     * Element of the character
     */
    get element(): Element | undefined;
    /**
     * Character rarity
     */
    get rarity(): number;
    /**
     * Weapon type
     */
    get weaponType(): WeaponType;
    /**
     * Body type
     */
    get bodyType(): BodyType;
    /**
     * Character promote level
     */
    get promoteLevel(): number;
    /**
     * Calculated character stats
     */
    get stats(): StatProperty[];
    /**
     * Default costume ID
     */
    get defaultCostumeId(): number;
    /**
     * Skill depot ID
     */
    get depotId(): number;
    /**
     * Skill order
     */
    get skillOrder(): number[];
    /**
     * Inherent skill order
     */
    get inherentSkillOrder(): number[];
    /**
     * Constellation IDs
     */
    get constellationIds(): number[];
    /**
     * Map of skill ID and proud ID
     */
    get proudMap(): Map<number, number>;
    /**
     * Character constellations
     */
    get constellations(): CharacterConstellation[];
    /**
     * Character inherent skills (passive talents)
     */
    get inherentSkills(): CharacterInherentSkill[];
    /**
     * Character ascension materials
     */
    get ascensionMaterials(): {
        id: number;
        count: number;
    }[];
    /**
     * Character profile
     */
    get profile(): CharacterProfile;
    /**
     * Character stories
     */
    get stories(): CharacterStory[];
    /**
     * Character voices
     */
    get voices(): CharacterVoice[];
    /**
     * Character costumes
     */
    get costumes(): CharacterCostume[];
    /**
     * Check if character can ascend to next level
     * @returns true if character can ascend
     */
    get isCanAscend(): boolean;
    /**
     * Get character summary information
     * @returns character summary object
     */
    get summary(): {
        name: string;
        element: Element | undefined;
        weapon: WeaponType;
        rarity: number;
        level: string;
        constellation: string;
    };
    /**
     * Get required materials for next ascension
     * @returns array of materials needed for next ascension
     */
    get nextAscensionMaterials(): {
        id: number;
        count: number;
    }[];
    /**
     * Get total materials needed from current to max level
     * @returns array of total materials needed
     */
    get totalAscensionMaterials(): {
        id: number;
        count: number;
    }[];
    /**
     * Get character ID by name
     * @param name character name
     * @returns character ID
     */
    static getCharacterIdByName(name: string): number[];
    /**
     * Get traveler skill depot IDs
     * @param characterId character ID
     * @returns skill depot IDs
     */
    static getTravelerSkillDepotIds(characterId: number): number[];
    /**
     * Get normal attack skill
     * @param skillLevel skill level (1-15). Default: 1
     * @returns normal attack skill
     */
    getNormalAttack(skillLevel?: number): CharacterSkill;
    /**
     * Get elemental skill
     * @param skillLevel skill level (1-15). Default: 1
     * @returns elemental skill
     */
    getElementalSkill(skillLevel?: number): CharacterSkill;
    /**
     * Get elemental burst
     * @param skillLevel skill level (1-15). Default: 1
     * @returns elemental burst
     */
    getElementalBurst(skillLevel?: number): CharacterSkill;
    /**
     * Get normal attack upgrade materials for a specific level
     * @param skillLevel skill level (1-15)
     * @returns array of materials needed
     */
    getNormalAttackMaterials(skillLevel: number): {
        id: number;
        count: number;
    }[];
    /**
     * Get elemental skill upgrade materials for a specific level
     * @param skillLevel skill level (1-15)
     * @returns array of materials needed
     */
    getElementalSkillMaterials(skillLevel: number): {
        id: number;
        count: number;
    }[];
    /**
     * Get elemental burst upgrade materials for a specific level
     * @param skillLevel skill level (1-15)
     * @returns array of materials needed
     */
    getElementalBurstMaterials(skillLevel: number): {
        id: number;
        count: number;
    }[];
    /**
     * Calculate total materials needed for character upgrade plan
     * @param plan character upgrade plan specifying level and skill changes
     * @returns array of total materials needed
     */
    calculateUpgradeMaterials(plan: CharacterUpgradePlan): {
        id: number;
        count: number;
    }[];
    /**
     * Get a specific skill by index
     * @param skillIndex skill index (0: Normal Attack, 1: Elemental Skill, 2: Elemental Burst)
     * @param skillLevel skill level (1-15). Default: 1
     * @returns character skill
     */
    private getSkill;
    /**
     * Get talent materials for a specific skill
     * @param skillIndex skill index (0: Normal Attack, 1: Elemental Skill, 2: Elemental Burst)
     * @param skillLevel skill level (1-15)
     * @returns array of materials needed
     */
    private getSkillMaterials;
    /**
     * Calculate character level upgrade materials
     * @param currentLevel current character level
     * @param targetLevel target character level
     * @returns array of materials needed
     */
    private calculateCharacterLevelMaterials;
    /**
     * Calculate skill level upgrade materials
     * @param skillIndex skill index
     * @param currentLevel current skill level
     * @param targetLevel target skill level
     * @returns array of materials needed
     */
    private calculateSkillLevelMaterials;
}

/**
 * Handles character ascension data including promote levels, costs, and stat bonuses
 */
declare class CharacterAscension {
    /**
     * Character ID
     */
    readonly id: number;
    /**
     * Character promote level
     */
    readonly promoteLevel: number;
    /**
     * Character ascension costItems
     */
    readonly costItems: {
        /**
         * Cost item ID(material ID)
         */
        id: number;
        /**
         * Cost item count
         */
        count: number;
    }[];
    /**
     * Character ascension costMora
     */
    readonly costMora: number;
    /**
     * Character ascension addProps
     */
    readonly addProps: StatProperty[];
    /**
     * Character ascension unlockMaxLevel
     */
    readonly unlockMaxLevel: number;
    /**
     * Create a character ascension
     * @param characterId character ID
     * @param promoteLevel character promote level (0-6). Default: 0
     */
    constructor(characterId: number, promoteLevel?: number);
    /**
     * Get max promote level by character ID
     * @param characterId character ID
     * @returns max promote level
     */
    static getMaxPromoteLevelByCharacterId(characterId: number): number;
}

/**
 * Represents a character's base statistical properties and attributes
 */
declare class CharacterBaseStats {
    /**
     * Character ID
     */
    readonly id: number;
    /**
     * Character level
     */
    readonly level: number;
    /**
     * Character promote level
     */
    readonly promoteLevel: number;
    /**
     * Character is ascended
     */
    readonly isAscended: boolean;
    /**
     * Character stats
     */
    readonly stats: StatProperty[];
    /**
     * Create a character's base stats
     * @param characterId character ID
     * @param level character level (1-100). Default: 1
     * @param isAscended character is ascended (true or false). Default: false
     */
    constructor(characterId: number, level?: number, isAscended?: boolean);
    /**
     * Calculate character's status
     * @param avatarJson avatar json
     * @param propGrowCurves prop grow curves
     * @param ascension character ascension
     * @returns character's status
     */
    private calculateStatus;
    /**
     * Get stat value by json
     * @param propGrowCurve json object
     * @param initValue initial value
     * @param addValue add value
     * @returns stat value
     */
    private getStatPropertyByJson;
}

/**
 * Contains basic information about a character
 */
declare class CharacterInfo {
    /**
     * Character ID
     */
    readonly id: number;
    /**
     * Default costume ID
     */
    readonly defaultCostumeId: number;
    /**
     * Character name
     */
    readonly name: string;
    /**
     * Character max level
     */
    readonly maxLevel: number;
    /**
     * Skill depot ID
     */
    readonly depotId: number;
    /**
     * Element of the character
     */
    readonly element: Element | undefined;
    /**
     * Skill order
     */
    readonly skillOrder: number[];
    /**
     * Inherent skill order
     */
    readonly inherentSkillOrder: number[];
    /**
     * Constellation IDs
     */
    readonly constellationIds: number[];
    /**
     * Map of skill ID and proud ID
     * @key Skill ID
     * @value Proud ID
     */
    readonly proudMap: Map<number, number>;
    /**
     * Character rarity (1-5 stars)
     * @warning Aloy has rarity 0 due to her special collaboration character status
     */
    readonly rarity: number;
    /**
     * Weapon type
     */
    readonly weaponType: WeaponType$1;
    /**
     * Body type
     */
    readonly bodyType: BodyType;
    /**
     * Create a CharacterInfo
     * @param characterId character ID
     * @param skillDepotId skill depot ID
     */
    constructor(characterId: number, skillDepotId?: number);
    /**
     * Get all character IDs
     * @returns all character IDs
     */
    static get allCharacterIds(): number[];
    /**
     * Get character ID by name
     * @param name character name
     * @returns character ID
     */
    static getCharacterIdByName(name: string): number[];
    /**
     * Get traveler skill depot IDs
     * @param characterId character ID
     * @returns skill depot IDs
     */
    static getTravelerSkillDepotIds(characterId: number): number[];
}

/**
 * Manages character skill leveling data including costs and stat bonuses
 */
declare class CharacterSkillAscension {
    /**
     * Skill ID
     */
    readonly id: number;
    /**
     * Skill level
     */
    readonly level: number;
    /**
     * Skill ascension costItems
     */
    readonly costItems: {
        /**
         * Cost item ID (materialID)
         */
        id: number;
        /**
         * Cost item count
         */
        count: number;
    }[];
    /**
     * Skill ascension costMora
     */
    readonly costMora: number;
    /**
     * Skill ascension addProps
     */
    readonly addProps: StatProperty[];
    /**
     * Create a character skill ascension
     * @param skillId skill ID
     * @param level skill level (1-15). Default: 1
     */
    constructor(skillId: number, level?: number);
}

/**
 * Domain data
 */
interface DomainData {
    /**
     * Domain name
     */
    readonly name: string;
    /**
     * Domain description
     */
    readonly description: string;
    /**
     * Reward Item IDs (material IDs)
     */
    readonly materialIds: number[];
    /**
     * CharacterInfos to use Reward Item.
     */
    readonly characterInfos: CharacterInfo[];
    /**
     * Weapon ID to use Reward Item.
     */
    readonly weaponIds: number[];
}
/**
 * Manages daily domain farming schedules and material availability by day
 */
declare class DailyFarming {
    /**
     * Map of dungeon entry ID and text map ID
     */
    private static readonly replaceTextMapIdMap;
    /**
     * Day-of-week (0-6)
     * @description 0: Sunday, 1: Monday, 2: Tuesday, 3: Wednesday, 4: Thursday, 5: Friday, 6: Saturday
     */
    readonly dayOfWeek: number;
    /**
     * Talent book IDs (Material IDs)
     */
    readonly talentBookIds: number[];
    /**
     * Weapon material IDs (Material IDs)
     */
    readonly weaponMaterialIds: number[];
    /**
     * Domains
     */
    readonly domains: DomainData[];
    /**
     * Create a DailyFarming
     * @description 0: Sunday, 1: Monday, 2: Tuesday, 3: Wednesday, 4: Thursday, 5: Friday, 6: Saturday
     * @param dayOfWeek day-of-week (0-6)
     */
    constructor(dayOfWeek: number);
    private getCharacterInfoByMaterialIds;
    private getWeaponIdsByMaterialIds;
}

/**
 * Represents a game monster with stats and properties
 */
declare class Monster {
    /**
     * Monster ID
     */
    readonly id: number;
    /**
     * Monster level
     */
    readonly level: number;
    /**
     * Player count for co-op scaling
     */
    readonly playerCount: number;
    /**
     * Monster Internal name
     */
    readonly internalName: string;
    /**
     * Monster name
     */
    readonly name: string;
    /**
     * Monster display name
     */
    readonly describeName: string;
    /**
     * Monster description
     */
    readonly description: string;
    /**
     * Monster display icon
     */
    readonly icon: ImageAssets | undefined;
    /**
     * Monster stats
     */
    readonly stats: StatProperty[];
    /**
     * Monster type
     */
    readonly codexType: SubType | undefined;
    /**
     * Create a Monster
     * @param monsterId monster ID
     * @param level monster level (1-100), defaults to 1
     * @param playerCount number of players (1-4), defaults to 1
     * @example
     * ```typescript
     * // Create a level 50 monster for single player
     * const monster = new Monster(21010101, 50)
     *
     * // Create a level 80 monster for co-op (4 players)
     * const coopMonster = new Monster(21010101, 80, 4)
     * ```
     */
    /**
     * Creates a new Monster instance
     * @param monsterId - Monster ID
     * @param level - Monster level
     * @param playerCount - Number of players for co-op scaling
     */
    constructor(monsterId: number, level?: number, playerCount?: number);
    /**
     * Get all monster IDs
     * @returns all monster IDs
     * @example
     * ```typescript
     * const allIds = Monster.allMonsterIds
     * console.log(`Total monsters: ${allIds.length}`)
     * ```
     */
    static get allMonsterIds(): number[];
    /**
     * Find monster ID by description ID
     * @param describeId description ID
     * @returns monster ID
     * @example
     * ```typescript
     * const monsterId = Monster.findMonsterIdByDescribeId(21104)
     * const monster = new Monster(monsterId)
     * ```
     */
    static findMonsterIdByDescribeId(describeId: number): number;
    /**
     * Get monster's stat value by stat type
     * @param propGrowCurve monsterExcelConfigData.propGrowCurves
     * @param initValue initial value
     * @param playerCount number of players
     * @returns stat value
     */
    private getStatValueByJson;
}

/**
 * Manages weapon refinement levels and passive ability improvements
 */
declare class WeaponRefinement {
    /**
     * Weapon ID
     */
    readonly id: number;
    /**
     * Weapon refinement rank
     */
    readonly refinementRank: number;
    /**
     * Weapon skill name
     */
    readonly skillName: string | undefined;
    /**
     * Weapon skill description
     */
    readonly skillDescription: string | undefined;
    /**
     * Weapon skill addProps
     */
    readonly addProps: StatProperty[];
    /**
     * Create a weapon refinement
     * @param weaponId weapon ID
     * @param refinementRank weapon refinement rank (1-5). Default: 1
     */
    constructor(weaponId: number, refinementRank?: number);
    /**
     * Get max refinement rank by weapon ID
     * @param weaponId weapon ID
     * @returns max refinement rank
     */
    static getMaxRefinementRankByWeaponId(weaponId: number): number;
}

/**
 * Unified weapon class providing comprehensive access to all weapon data
 */
declare class Weapon {
    /**
     * Weapon ID
     */
    readonly id: number;
    /**
     * Weapon level
     */
    readonly level: number;
    /**
     * Weapon is ascended
     */
    readonly isAscended: boolean;
    /**
     * Weapon refinement rank
     */
    readonly refinementRank: number;
    /**
     * Weapon info instance
     */
    private readonly info;
    /**
     * Weapon ascension instance
     */
    private readonly ascension;
    /**
     * Weapon refinement instance
     */
    private readonly refinement;
    /**
     * Create a Weapon
     * @param weaponId weapon ID
     * @param level weapon level (1-90). Default: 1
     * @param isAscended weapon is ascended. Default: true
     * @param refinementRank weapon refinement rank (1-5). Default: 1
     */
    constructor(weaponId: number, level?: number, isAscended?: boolean, refinementRank?: number);
    /**
     * Get all weapon IDs
     * @returns all weapon IDs
     */
    static get allWeaponIds(): number[];
    /**
     * Weapon name
     */
    get name(): string;
    /**
     * Weapon description
     */
    get description(): string;
    /**
     * Weapon type
     */
    get type(): WeaponType;
    /**
     * Weapon skill name
     */
    get skillName(): string | undefined;
    /**
     * Weapon skill description
     */
    get skillDescription(): string | undefined;
    /**
     * Weapon max level
     */
    get maxLevel(): number;
    /**
     * Weapon promote level
     */
    get promoteLevel(): number;
    /**
     * Weapon rarity
     */
    get rarity(): number;
    /**
     * Calculated weapon stats
     */
    get stats(): StatProperty[];
    /**
     * Whether the weapon is awakened
     */
    get isAwaken(): boolean;
    /**
     * Weapon icon
     */
    get icon(): ImageAssets;
    /**
     * Weapon ascension materials
     */
    get ascensionMaterials(): {
        id: number;
        count: number;
    }[];
    /**
     * Weapon refinement effects
     */
    get refinementAddProps(): StatProperty[];
    /**
     * Get weapon summary information
     * @returns weapon summary object
     */
    get summary(): {
        name: string;
        type: WeaponType;
        rarity: number;
        level: string;
        refinement: string;
    };
    /**
     * Check if weapon can ascend to next level
     * @returns true if weapon can ascend
     */
    get isCanAscend(): boolean;
    /**
     * Get required materials for next ascension
     * @returns array of materials needed for next ascension
     */
    get nextAscensionMaterials(): {
        id: number;
        count: number;
    }[];
    /**
     * Get total materials needed from current to max level
     * @returns array of total materials needed
     */
    get totalAscensionMaterials(): {
        id: number;
        count: number;
    }[];
    /**
     * Check if weapon can refine to next rank
     * @returns true if weapon can refine
     */
    get isCanRefine(): boolean;
    /**
     * Get max refinement rank for this weapon
     * @returns max refinement rank
     */
    get maxRefinementRank(): number;
    /**
     * Get weapon ID by name
     * @param name weapon name
     * @returns weapon ID
     */
    static getWeaponIdByName(name: string): number[];
    /**
     * Get refinement effect for specified rank
     * @param rank refinement rank (1-5). Default: current rank
     * @returns refinement effect
     */
    getRefinementEffect(rank?: number): WeaponRefinement;
    /**
     * Calculate weapon level upgrade materials
     * @param currentLevel current weapon level
     * @param targetLevel target weapon level
     * @returns array of materials needed
     */
    calculateWeaponLevelMaterials(currentLevel: number, targetLevel: number): {
        id: number;
        count: number;
    }[];
}

/**
 * Handles weapon enhancement data including promote levels, costs, and stat boosts
 */
declare class WeaponAscension {
    /**
     * Weapon ID
     */
    readonly id: number;
    /**
     * Weapon promote level
     */
    readonly promoteLevel: number;
    /**
     * Weapon ascension costItems
     */
    readonly costItems: {
        /**
         * Cost item ID(materialIDd)
         */
        id: number;
        /**
         * Cost item count
         */
        count: number;
    }[];
    /**
     * Weapon ascension costMora
     */
    readonly costMora: number;
    /**
     * Weapon ascension addProps
     */
    readonly addProps: StatProperty[];
    /**
     * Weapon ascension unlockMaxLevel
     */
    readonly unlockMaxLevel: number;
    /**
     * Create a weapon ascension
     * @param weaponId weapon ID
     * @param promoteLevel weapon promote level (0-6). Default: 0
     */
    constructor(weaponId: number, promoteLevel?: number);
    /**
     * Get max promote level by weapon ID
     * @param weaponId weapon ID
     * @returns max promote level
     */
    static getMaxPromoteLevelByWeaponId(weaponId: number): number;
}

/**
 * Convert the date string to UTC
 * @param dateString date string
 * @param region game region
 * @returns UTC date
 */
declare function convertToUTC(dateString: string, region: Region): Date;

/**
 * Comprehensive error code enumeration for genshin-manager
 */
declare enum GenshinManagerErrorCode {
    GM_VALIDATION_RANGE = "GM1001",
    GM_VALIDATION_TYPE = "GM1002",
    GM_VALIDATION_REQUIRED = "GM1003",
    GM_VALIDATION_FORMAT = "GM1004",
    GM_VALIDATION_ENUM = "GM1005",
    GM_ASSETS_NOT_FOUND = "GM2001",
    GM_ASSETS_CORRUPTED = "GM2002",
    GM_ASSETS_DOWNLOAD_FAILED = "GM2003",
    GM_ASSETS_AUDIO_NOT_FOUND = "GM2004",
    GM_ASSETS_IMAGE_NOT_FOUND = "GM2005",
    GM_DECODE_MASTER_NOT_FOUND = "GM3001",
    GM_DECODE_PATTERN_MISMATCH = "GM3002",
    GM_DECODE_LOW_CONFIDENCE = "GM3003",
    GM_DECODE_KEY_MATCHING_FAILED = "GM3004",
    GM_NETWORK_TIMEOUT = "GM4001",
    GM_NETWORK_UNAVAILABLE = "GM4002",
    GM_NETWORK_ENKA_ERROR = "GM4003",
    GM_NETWORK_ENKA_STATUS_ERROR = "GM4004",
    GM_CONFIG_INVALID = "GM5001",
    GM_CONFIG_MISSING = "GM5002",
    GM_CONTENT_ANN_NOT_FOUND = "GM6001",
    GM_CONTENT_BODY_NOT_FOUND = "GM6002",
    GM_CONTENT_TEXT_MAP_FORMAT = "GM6003",
    GM_GENERAL_UNKNOWN = "GM9001"
}
/**
 * Error category mapping
 */
declare const errorCategories: {
    readonly GM1001: "VALIDATION";
    readonly GM1002: "VALIDATION";
    readonly GM1003: "VALIDATION";
    readonly GM1004: "VALIDATION";
    readonly GM1005: "VALIDATION";
    readonly GM2001: "ASSETS";
    readonly GM2002: "ASSETS";
    readonly GM2003: "ASSETS";
    readonly GM2004: "ASSETS";
    readonly GM2005: "ASSETS";
    readonly GM3001: "DECODING";
    readonly GM3002: "DECODING";
    readonly GM3003: "DECODING";
    readonly GM3004: "DECODING";
    readonly GM4001: "NETWORK";
    readonly GM4002: "NETWORK";
    readonly GM4003: "NETWORK";
    readonly GM4004: "NETWORK";
    readonly GM5001: "CONFIG";
    readonly GM5002: "CONFIG";
    readonly GM6001: "CONTENT";
    readonly GM6002: "CONTENT";
    readonly GM6003: "CONTENT";
    readonly GM9001: "GENERAL";
};
/**
 * Error category type
 */
type ErrorCategory = (typeof errorCategories)[keyof typeof errorCategories];
/**
 * Retry classification for errors
 */
declare const retryClassifications: {
    readonly GM1001: {
        readonly isRetryable: false;
    };
    readonly GM1002: {
        readonly isRetryable: false;
    };
    readonly GM1003: {
        readonly isRetryable: false;
    };
    readonly GM1004: {
        readonly isRetryable: false;
    };
    readonly GM1005: {
        readonly isRetryable: false;
    };
    readonly GM2001: {
        readonly isRetryable: true;
        readonly maxRetries: 3;
        readonly retryDelay: 1000;
        readonly backoffMultiplier: 2;
    };
    readonly GM2002: {
        readonly isRetryable: false;
    };
    readonly GM2003: {
        readonly isRetryable: true;
        readonly maxRetries: 3;
        readonly retryDelay: 2000;
        readonly backoffMultiplier: 2;
    };
    readonly GM2004: {
        readonly isRetryable: true;
        readonly maxRetries: 2;
        readonly retryDelay: 1000;
    };
    readonly GM2005: {
        readonly isRetryable: true;
        readonly maxRetries: 2;
        readonly retryDelay: 1000;
    };
    readonly GM3001: {
        readonly isRetryable: false;
    };
    readonly GM3002: {
        readonly isRetryable: false;
    };
    readonly GM3003: {
        readonly isRetryable: false;
    };
    readonly GM3004: {
        readonly isRetryable: false;
    };
    readonly GM4001: {
        readonly isRetryable: true;
        readonly maxRetries: 3;
        readonly retryDelay: 1000;
        readonly backoffMultiplier: 2;
    };
    readonly GM4002: {
        readonly isRetryable: true;
        readonly maxRetries: 5;
        readonly retryDelay: 5000;
        readonly backoffMultiplier: 1.5;
    };
    readonly GM4003: {
        readonly isRetryable: true;
        readonly maxRetries: 3;
        readonly retryDelay: 2000;
    };
    readonly GM4004: {
        readonly isRetryable: true;
        readonly maxRetries: 2;
        readonly retryDelay: 3000;
    };
    readonly GM5001: {
        readonly isRetryable: false;
    };
    readonly GM5002: {
        readonly isRetryable: false;
    };
    readonly GM6001: {
        readonly isRetryable: true;
        readonly maxRetries: 2;
        readonly retryDelay: 1000;
    };
    readonly GM6002: {
        readonly isRetryable: true;
        readonly maxRetries: 2;
        readonly retryDelay: 1000;
    };
    readonly GM6003: {
        readonly isRetryable: false;
    };
    readonly GM9001: {
        readonly isRetryable: true;
        readonly maxRetries: 1;
        readonly retryDelay: 2000;
    };
};
/**
 * Retry configuration interface
 */
interface RetryConfiguration {
    /**
     * Whether this error should be retried
     */
    readonly isRetryable: boolean;
    /**
     * Maximum number of retry attempts
     */
    readonly maxRetries?: number;
    /**
     * Delay between retry attempts in milliseconds
     */
    readonly retryDelay?: number;
    /**
     * Multiplier for exponential backoff
     */
    readonly backoffMultiplier?: number;
}

/**
 * Rich error context interface for debugging and troubleshooting
 */
interface ErrorContext {
    /**
     * File path where the error occurred
     */
    readonly filePath?: string;
    /**
     * JSON file associated with the error
     */
    readonly jsonFile?: string;
    /**
     * Image file associated with the error
     */
    readonly imageFile?: string;
    /**
     * Audio file associated with the error
     */
    readonly audioFile?: string;
    /**
     * URL associated with the error
     */
    readonly url?: string;
    /**
     * HTTP request method used
     */
    readonly requestMethod?: string;
    /**
     * HTTP status code received
     */
    readonly statusCode?: number;
    /**
     * HTTP response headers
     */
    readonly responseHeaders?: Record<string, string>;
    /**
     * Property or field name that failed validation
     */
    readonly propertyKey?: string;
    /**
     * Source data that caused the error
     */
    readonly sourceData?: string;
    /**
     * Target data expected
     */
    readonly targetData?: string;
    /**
     * Type of data being processed
     */
    readonly dataType?: string;
    /**
     * Operation being performed when error occurred
     */
    readonly operation?: string;
    /**
     * Expected value for validation
     */
    readonly expectedValue?: unknown;
    /**
     * Actual value that failed validation
     */
    readonly actualValue?: unknown;
    /**
     * Path to the property that failed validation
     */
    readonly validationPath?: string;
    /**
     * Timestamp when error occurred
     */
    readonly timestamp?: Date;
    /**
     * Duration of operation in milliseconds
     */
    readonly duration?: number;
    /**
     * Stack trace at error location
     */
    readonly stackTrace?: string;
    /**
     * User agent string
     */
    readonly userAgent?: string;
    /**
     * Environment information
     */
    readonly environmentInfo?: Record<string, unknown>;
    /**
     * Additional metadata for the error
     */
    readonly metadata?: Record<string, unknown>;
}
/**
 * Factory for creating common error contexts
 */
declare const ErrorContextFactory: {
    /**
     * Create file-related error context
     */
    createFileContext(filePath: string, operation?: string): ErrorContext;
    /**
     * Create network-related error context
     */
    createNetworkContext(url: string, requestMethod?: string, statusCode?: number, responseHeaders?: Record<string, string>): ErrorContext;
    /**
     * Create validation-related error context
     */
    createValidationContext(propertyKey: string, expectedValue: unknown, actualValue: unknown, validationPath?: string): ErrorContext;
    /**
     * Create decoding-related error context
     */
    createDecodingContext(sourceData: string, targetData?: string, operation?: string): ErrorContext;
    /**
     * Create asset-related error context
     */
    createAssetContext(filePath?: string, imageFile?: string, audioFile?: string, operation?: string): ErrorContext;
    /**
     * Create configuration-related error context
     */
    createConfigContext(propertyKey: string, jsonFile?: string, expectedValue?: unknown, actualValue?: unknown): ErrorContext;
    /**
     * Merge multiple error contexts
     */
    merge(...contexts: (ErrorContext | undefined)[]): ErrorContext;
};

/**
 * Unified base error class for genshin-manager with comprehensive error handling
 */
declare abstract class GenshinManagerError extends Error {
    /**
     * Whether this error originated from genshin-manager library
     */
    readonly isGenshinManagerError = true;
    /**
     * Error category for grouping and handling
     */
    readonly category: ErrorCategory;
    /**
     * Rich context information for debugging
     */
    readonly context?: ErrorContext;
    /**
     * Retry configuration based on error type
     */
    readonly retryConfig: RetryConfiguration;
    /**
     * Timestamp when the error occurred
     */
    readonly timestamp: Date;
    /**
     * Original error that caused this error (Node.js 16.9.0+)
     */
    readonly cause?: Error;
    /**
     * Unique error code for identification and classification
     */
    abstract readonly errorCode: GenshinManagerErrorCode;
    /**
     * Constructor for GenshinManagerError
     * @param message - Human-readable error message
     * @param context - Rich error context for debugging
     * @param cause - Original error that caused this error
     */
    constructor(message: string, context?: ErrorContext, cause?: Error);
    /**
     * Static helper to check if an error is a GenshinManagerError
     */
    static isGenshinManagerError(error: unknown): error is GenshinManagerError;
    /**
     * Static helper to create error from unknown type
     */
    static fromUnknown(error: unknown, fallbackMessage?: string, context?: ErrorContext): Promise<GenshinManagerError>;
    /**
     * Generate detailed error message with context information
     */
    getDetailedMessage(): string;
    /**
     * Check if this error is retryable
     */
    isRetryable(): boolean;
    /**
     * Get retry configuration
     */
    getRetryConfig(): RetryConfiguration;
    /**
     * Serialize error for logging or transport
     */
    toJSON(): Record<string, unknown>;
    /**
     * Create a copy of this error with additional context
     */
    withContext(additionalContext: Partial<ErrorContext>): this;
    /**
     * Initialize category and retry configuration after errorCode is available
     */
    private initializeConfig;
}

/**
 * Validation error for Zod schema validation failures
 */
declare class ValidationError extends GenshinManagerError {
    readonly errorCode: GenshinManagerErrorCode;
    /**
     * Zod validation issues for detailed error information
     */
    readonly zodIssues?: z.ZodIssue[];
    /**
     * Constructor for ValidationError
     * @param message - Human-readable error message
     * @param context - Error context
     * @param zodIssues - Zod validation issues
     * @param cause - Original error
     */
    constructor(message: string, context?: ErrorContext, zodIssues?: z.ZodIssue[], cause?: Error);
    /**
     * Create ValidationError from Zod error
     */
    static fromZodError(zodError: z.ZodError, context?: ErrorContext): ValidationError;
    /**
     * Get detailed validation error information
     */
    getValidationDetails(): {
        path: string;
        issue: string;
        expected?: unknown;
        received?: unknown;
    }[];
    /**
     * Get formatted error message with all validation issues
     */
    getFormattedMessage(): string;
}

/**
 * Enum validation error
 */
declare class EnumValidationError extends ValidationError {
    readonly errorCode = GenshinManagerErrorCode.GM_VALIDATION_ENUM;
    /**
     * Constructor for EnumValidationError
     * @param value - The invalid value
     * @param allowedValues - Array of allowed values
     * @param propertyName - Name of the property being validated
     * @param context - Additional error context
     * @param cause - Original error
     */
    constructor(value: unknown, allowedValues: unknown[], propertyName?: string, context?: ErrorContext, cause?: Error);
}

/**
 * Format validation error
 */
declare class FormatValidationError extends ValidationError {
    readonly errorCode = GenshinManagerErrorCode.GM_VALIDATION_FORMAT;
    /**
     * Constructor for FormatValidationError
     * @param value - The invalid value
     * @param expectedFormat - Description of expected format
     * @param propertyName - Name of the property being validated
     * @param context - Additional error context
     * @param cause - Original error
     */
    constructor(value: unknown, expectedFormat: string, propertyName?: string, context?: ErrorContext, cause?: Error);
}

/**
 * Range validation error for numeric value validation
 */
declare class RangeValidationError extends ValidationError {
    readonly errorCode = GenshinManagerErrorCode.GM_VALIDATION_RANGE;
    /**
     * Constructor for RangeValidationError
     * @param value - The value that was out of range
     * @param min - Minimum allowed value
     * @param max - Maximum allowed value
     * @param propertyName - Name of the property being validated
     * @param context - Additional error context
     * @param cause - Original error
     */
    constructor(value: number, min: number, max: number, propertyName?: string, context?: ErrorContext, cause?: Error);
}

/**
 * Required field validation error
 */
declare class RequiredFieldError extends ValidationError {
    readonly errorCode = GenshinManagerErrorCode.GM_VALIDATION_REQUIRED;
    /**
     * Constructor for RequiredFieldError
     * @param fieldName - Name of the required field
     * @param context - Additional error context
     * @param cause - Original error
     */
    constructor(fieldName: string, context?: ErrorContext, cause?: Error);
}

/**
 * Base asset error class
 */
declare abstract class AssetError extends GenshinManagerError {
    /**
     * Asset file path or identifier
     */
    readonly assetPath: string;
    /**
     * Asset type (image, audio, etc.)
     */
    readonly assetType: string;
    /**
     * Constructor for AssetError
     * @param message - Error message
     * @param assetPath - Asset file path or identifier
     * @param assetType - Type of asset
     * @param context - Additional error context
     * @param cause - Original error
     */
    constructor(message: string, assetPath: string, assetType: string, context?: ErrorContext, cause?: Error);
}

/**
 * Asset corrupted error
 */
declare class AssetCorruptedError extends AssetError {
    readonly errorCode = GenshinManagerErrorCode.GM_ASSETS_CORRUPTED;
    /**
     * Details about the corruption
     */
    readonly corruptionDetails?: string;
    /**
     * Constructor for AssetCorruptedError
     * @param assetPath - Asset file path or identifier
     * @param assetType - Type of asset
     * @param corruptionDetails - Details about the corruption
     * @param context - Additional error context
     * @param cause - Original error
     */
    constructor(assetPath: string, assetType: string, corruptionDetails?: string, context?: ErrorContext, cause?: Error);
}

/**
 * Asset download failed error
 */
declare class AssetDownloadFailedError extends AssetError {
    readonly errorCode = GenshinManagerErrorCode.GM_ASSETS_DOWNLOAD_FAILED;
    /**
     * Download URL if different from asset path
     */
    readonly downloadUrl?: string;
    /**
     * HTTP status code if available
     */
    readonly statusCode?: number;
    /**
     * Constructor for AssetDownloadFailedError
     * @param assetPath - Asset file path or identifier
     * @param assetType - Type of asset
     * @param downloadUrl - Download URL
     * @param statusCode - HTTP status code
     * @param context - Additional error context
     * @param cause - Original error
     */
    constructor(assetPath: string, assetType: string, downloadUrl?: string, statusCode?: number, context?: ErrorContext, cause?: Error);
}

/**
 * Factory for creating asset errors
 */
declare const AssetErrorFactory: {
    /**
     * Create asset error based on the type of failure
     */
    createFromFailure(assetPath: string, assetType: string, failureType: "not_found" | "corrupted" | "download_failed", details?: {
        downloadUrl?: string;
        statusCode?: number;
        corruptionDetails?: string;
        context?: ErrorContext;
        cause?: Error;
    }): AssetError;
    /**
     * Create image-specific error
     */
    createImageError(imagePath: string, failureType: "not_found" | "corrupted" | "download_failed", details?: {
        downloadUrl?: string;
        statusCode?: number;
        corruptionDetails?: string;
        context?: ErrorContext;
        cause?: Error;
    }): AssetError;
    /**
     * Create audio-specific error
     */
    createAudioError(audioPath: string, failureType: "not_found" | "corrupted" | "download_failed", details?: {
        downloadUrl?: string;
        statusCode?: number;
        corruptionDetails?: string;
        context?: ErrorContext;
        cause?: Error;
    }): AssetError;
};

/**
 * Asset not found error
 */
declare class AssetNotFoundError extends AssetError {
    readonly errorCode = GenshinManagerErrorCode.GM_ASSETS_NOT_FOUND;
    /**
     * Constructor for AssetNotFoundError
     * @param assetPath - Asset file path or identifier
     * @param assetType - Type of asset
     * @param context - Additional error context
     * @param cause - Original error
     */
    constructor(assetPath: string, assetType?: string, context?: ErrorContext, cause?: Error);
}

/**
 * Audio not found error
 */
declare class AudioNotFoundError extends AssetError {
    readonly errorCode = GenshinManagerErrorCode.GM_ASSETS_AUDIO_NOT_FOUND;
    /**
     * Constructor for AudioNotFoundError
     * @param audioPath - Audio file path or identifier
     * @param context - Additional error context
     * @param cause - Original error
     */
    constructor(audioPath: string, context?: ErrorContext, cause?: Error);
}

/**
 * Image not found error
 */
declare class ImageNotFoundError extends AssetError {
    readonly errorCode = GenshinManagerErrorCode.GM_ASSETS_IMAGE_NOT_FOUND;
    /**
     * Constructor for ImageNotFoundError
     * @param imagePath - Image file path or identifier
     * @param context - Additional error context
     * @param cause - Original error
     */
    constructor(imagePath: string, context?: ErrorContext, cause?: Error);
}

/**
 * Abstract base class for network-related errors
 */
declare abstract class NetworkError extends GenshinManagerError {
    /**
     * URL associated with the network request
     */
    readonly url?: string;
    /**
     * HTTP method used
     */
    readonly method?: string;
    /**
     * HTTP status code if available
     */
    readonly statusCode?: number;
    /**
     * Request timeout in milliseconds
     */
    readonly timeout?: number;
    /**
     * Constructor for NetworkError
     * @param message - Error message
     * @param url - Request URL
     * @param method - HTTP method
     * @param statusCode - HTTP status code
     * @param timeout - Request timeout
     * @param context - Additional error context
     * @param cause - Original error
     */
    constructor(message: string, url?: string, method?: string, statusCode?: number, timeout?: number, context?: ErrorContext, cause?: Error);
}

/**
 * Enka Network API error
 */
declare class EnkaNetworkError extends NetworkError {
    readonly errorCode = GenshinManagerErrorCode.GM_NETWORK_ENKA_ERROR;
    /**
     * Enka API error code if available
     */
    readonly enkaErrorCode?: string;
    /**
     * Constructor for EnkaNetworkError
     * @param message - Error message
     * @param url - Request URL
     * @param statusCode - HTTP status code
     * @param enkaErrorCode - Enka-specific error code
     * @param method - HTTP method
     * @param context - Additional error context
     * @param cause - Original error
     */
    constructor(message: string, url?: string, statusCode?: number, enkaErrorCode?: string, method?: string, context?: ErrorContext, cause?: Error);
    /**
     * Create EnkaNetworkError from API response
     * @param response - Fetch response object
     * @param responseBody - Response body if available
     * @param context - Additional error context
     */
    static fromResponse(response: Response, responseBody?: unknown, context?: ErrorContext): EnkaNetworkError;
}

/**
 * Enka Network status-related error (maintenance, rate limiting, etc.)
 */
declare class EnkaNetworkStatusError extends NetworkError {
    readonly errorCode = GenshinManagerErrorCode.GM_NETWORK_ENKA_STATUS_ERROR;
    /**
     * Type of status error
     */
    readonly statusType: 'maintenance' | 'rate_limit' | 'unavailable';
    /**
     * Retry after duration in seconds (for rate limiting)
     */
    readonly retryAfter?: number;
    /**
     * Constructor for EnkaNetworkStatusError
     * @param message - Error message
     * @param statusType - Type of status error
     * @param url - Request URL
     * @param statusCode - HTTP status code
     * @param retryAfter - Retry after duration in seconds
     * @param context - Additional error context
     * @param cause - Original error
     */
    constructor(message: string, statusType: 'maintenance' | 'rate_limit' | 'unavailable', url?: string, statusCode?: number, retryAfter?: number, context?: ErrorContext, cause?: Error);
    /**
     * Create rate limit error
     * @param retryAfter - Retry after duration in seconds
     * @param url - Request URL
     * @param context - Additional error context
     */
    static createRateLimitError(retryAfter: number, url?: string, context?: ErrorContext): EnkaNetworkStatusError;
    /**
     * Create maintenance error
     * @param url - Request URL
     * @param context - Additional error context
     */
    static createMaintenanceError(url?: string, context?: ErrorContext): EnkaNetworkStatusError;
}

/**
 * Network timeout error
 */
declare class NetworkTimeoutError extends NetworkError {
    readonly errorCode = GenshinManagerErrorCode.GM_NETWORK_TIMEOUT;
    /**
     * Constructor for NetworkTimeoutError
     * @param url - Request URL
     * @param timeout - Timeout duration in milliseconds
     * @param method - HTTP method
     * @param context - Additional error context
     * @param cause - Original error
     */
    constructor(url: string, timeout: number, method?: string, context?: ErrorContext, cause?: Error);
}

/**
 * Network unavailable error
 */
declare class NetworkUnavailableError extends NetworkError {
    readonly errorCode = GenshinManagerErrorCode.GM_NETWORK_UNAVAILABLE;
    /**
     * Constructor for NetworkUnavailableError
     * @param url - Request URL
     * @param method - HTTP method
     * @param context - Additional error context
     * @param cause - Original error
     */
    constructor(url?: string, method?: string, context?: ErrorContext, cause?: Error);
}

/**
 * Key matching failure error for encrypted key decoding
 */
declare class KeyMatchingError extends GenshinManagerError {
    readonly errorCode = GenshinManagerErrorCode.GM_DECODE_KEY_MATCHING_FAILED;
    /**
     * Encrypted keys that failed to match
     */
    readonly failedKeys: string[];
    /**
     * Expected keys from master file
     */
    readonly expectedKeys: string[];
    /**
     * Constructor for KeyMatchingError
     * @param sourceFile - Source file being decoded
     * @param failedKeys - Keys that failed to match
     * @param expectedKeys - Expected keys from master file
     * @param context - Additional error context
     */
    constructor(sourceFile: string, failedKeys: string[], expectedKeys: string[], context?: ErrorContext);
    /**
     * Get detailed key matching information
     */
    getKeyMatchingDetails(): {
        failedKeys: string[];
        expectedKeys: string[];
        unmatchedExpected: string[];
        successRate: number;
    };
    /**
     * Get suggestions for troubleshooting
     */
    getTroubleshootingSuggestions(): string[];
}

/**
 * Low confidence error for encrypted key decoding
 */
declare class LowConfidenceError extends GenshinManagerError {
    readonly errorCode = GenshinManagerErrorCode.GM_DECODE_LOW_CONFIDENCE;
    /**
     * Constructor for LowConfidenceError
     * @param sourceFile - Source file being decoded
     * @param confidence - Confidence level achieved
     * @param threshold - Minimum required confidence
     * @param context - Additional error context
     */
    constructor(sourceFile: string, confidence: number, threshold?: number, context?: ErrorContext);
}

/**
 * Master file configuration error for encrypted key decoding issues
 */
declare class MasterFileConfigurationError extends GenshinManagerError {
    readonly errorCode = GenshinManagerErrorCode.GM_DECODE_MASTER_NOT_FOUND;
    /**
     * Constructor for MasterFileConfigurationError
     * @param masterFilePath - Path to the master file
     * @param context - Additional error context
     * @param cause - Original error
     */
    constructor(masterFilePath: string, context?: ErrorContext, cause?: Error);
}

/**
 * Pattern mismatch error for encrypted key decoding
 */
declare class PatternMismatchError extends GenshinManagerError {
    readonly errorCode = GenshinManagerErrorCode.GM_DECODE_PATTERN_MISMATCH;
    /**
     * Constructor for PatternMismatchError
     * @param sourceFile - Source file being decoded
     * @param confidence - Confidence level achieved
     * @param context - Additional error context
     */
    constructor(sourceFile: string, confidence: number, context?: ErrorContext);
}

/**
 * Announcement content not found error
 */
declare class AnnContentNotFoundError extends GenshinManagerError {
    readonly errorCode = GenshinManagerErrorCode.GM_CONTENT_ANN_NOT_FOUND;
    /**
     * Announcement ID or identifier
     */
    readonly announcementId: string;
    /**
     * Constructor for AnnContentNotFoundError
     * @param announcementId - Announcement ID or identifier
     * @param context - Additional error context
     * @param cause - Original error
     */
    constructor(announcementId: string, context?: ErrorContext, cause?: Error);
}

/**
 * Body content not found error
 */
declare class BodyNotFoundError extends GenshinManagerError {
    readonly errorCode = GenshinManagerErrorCode.GM_CONTENT_BODY_NOT_FOUND;
    /**
     * Content type or identifier
     */
    readonly contentType: string;
    /**
     * Constructor for BodyNotFoundError
     * @param contentType - Content type or identifier
     * @param context - Additional error context
     * @param cause - Original error
     */
    constructor(contentType: string, context?: ErrorContext, cause?: Error);
}

/**
 * Text map format error
 */
declare class TextMapFormatError extends GenshinManagerError {
    readonly errorCode = GenshinManagerErrorCode.GM_CONTENT_TEXT_MAP_FORMAT;
    /**
     * Text map key or identifier
     */
    readonly textMapKey: string;
    /**
     * Expected format description
     */
    readonly expectedFormat: string;
    /**
     * Constructor for TextMapFormatError
     * @param textMapKey - Text map key or identifier
     * @param expectedFormat - Expected format description
     * @param actualValue - Actual invalid value
     * @param context - Additional error context
     * @param cause - Original error
     */
    constructor(textMapKey: string, expectedFormat: string, actualValue: unknown, context?: ErrorContext, cause?: Error);
}

/**
 * Configuration invalid error
 */
declare class ConfigInvalidError extends GenshinManagerError {
    readonly errorCode = GenshinManagerErrorCode.GM_CONFIG_INVALID;
    /**
     * Configuration property that is invalid
     */
    readonly configProperty: string;
    /**
     * Configuration file path if applicable
     */
    readonly configFile?: string;
    /**
     * Constructor for ConfigInvalidError
     * @param configProperty - Configuration property that is invalid
     * @param expectedValue - Expected value or type
     * @param actualValue - Actual invalid value
     * @param configFile - Configuration file path
     * @param context - Additional error context
     * @param cause - Original error
     */
    constructor(configProperty: string, expectedValue: unknown, actualValue: unknown, configFile?: string, context?: ErrorContext, cause?: Error);
}

/**
 * Configuration missing error
 */
declare class ConfigMissingError extends GenshinManagerError {
    readonly errorCode = GenshinManagerErrorCode.GM_CONFIG_MISSING;
    /**
     * Missing configuration property
     */
    readonly configProperty: string;
    /**
     * Configuration file path if applicable
     */
    readonly configFile?: string;
    /**
     * Constructor for ConfigMissingError
     * @param configProperty - Missing configuration property
     * @param configFile - Configuration file path
     * @param context - Additional error context
     * @param cause - Original error
     */
    constructor(configProperty: string, configFile?: string, context?: ErrorContext, cause?: Error);
}

/**
 * General error for unknown or uncategorized errors
 */
declare class GeneralError extends GenshinManagerError {
    readonly errorCode = GenshinManagerErrorCode.GM_GENERAL_UNKNOWN;
}

/**
 * Validation helper utilities for type-safe validation with error handling
 */
declare class ValidationHelper {
    private constructor();
    /**
     * Validate data against a Zod schema with proper error handling
     * @param schema - Zod schema to validate against
     * @param data - Data to validate
     * @param context - Additional error context
     * @returns validated data
     * @throws ValidationError if validation fails
     */
    static validate<T>(schema: z.ZodSchema<T>, data: unknown, context?: ErrorContext): T;
    /**
     * Validate object with multiple properties
     * @param obj - Object to validate
     * @param validations - Validation configurations for each property
     * @param context - Additional error context
     * @returns validated object
     * @throws ValidationError if any property validation fails
     */
    static validateObject<T extends Record<string, unknown>>(obj: unknown, validations: {
        [K in keyof T]: z.ZodSchema<T[K]>;
    }, context?: ErrorContext): T;
    /**
     * Safely validate data and return result with success/error information
     * @param schema - Zod schema to validate against
     * @param data - Data to validate
     * @param context - Additional error context
     * @returns validation result
     */
    staticsafeValidate<T>(schema: z.ZodSchema<T>, data: unknown, context?: ErrorContext): {
        success: true;
        data: T;
    } | {
        success: false;
        error: ValidationError;
    };
    /**
     * Validate required field
     * @param value - Value to validate
     * @param fieldName - Name of the field being validated
     * @param context - Additional error context
     * @returns validated value
     * @throws RequiredFieldError if validation fails
     */
    staticvalidateRequired<T>(value: T | null | undefined, fieldName: string, context?: ErrorContext): T;
    /**
     * Validate enum value
     * @param value - Value to validate
     * @param allowedValues - Array of allowed values
     * @param fieldName - Name of the field being validated
     * @param context - Additional error context
     * @returns validated value
     * @throws EnumValidationError if validation fails
     */
    staticvalidateEnum<T>(value: unknown, allowedValues: readonly T[], fieldName: string, context?: ErrorContext): T;
    /**
     * Validate string format using regex
     * @param value - String to validate
     * @param pattern - Regex pattern
     * @param fieldName - Name of the field being validated
     * @param expectedFormat - Description of expected format
     * @param context - Additional error context
     * @returns validated string
     * @throws FormatValidationError if validation fails
     */
    staticvalidateFormat(value: string, pattern: RegExp, fieldName: string, expectedFormat: string, context?: ErrorContext): string;
    /**
     * Create a validation function from a Zod schema
     * @param schema - Zod schema
     * @param fieldName - Name of the field for error messages
     * @returns validation function
     */
    staticcreateValidator<T>(schema: z.ZodSchema<T>, fieldName: string): (data: unknown, context?: ErrorContext) => T;
    /**
     * Batch validate multiple values with different schemas
     * @param validations - Array of validation configurations
     * @returns array of validated values
     * @throws ValidationError if any validation fails
     */
    staticbatchValidate<T extends readonly unknown[]>(validations: {
        readonly [K in keyof T]: {
            schema: z.ZodSchema<T[K]>;
            data: unknown;
            fieldName: string;
            context?: ErrorContext;
        };
    }): T;
}

/**
 * Dynamic artifact level validation schema factory (0 to maxLevel)
 * @param maxLevel Maximum artifact level based on rarity
 * @returns Zod number schema for artifact level validation
 */
declare function createArtifactLevelSchema(maxLevel: number): z.ZodNumber;

/**
 * Dynamic weapon level validation schema factory (1 to maxLevel)
 * @param maxLevel Maximum weapon level based on ascension
 * @returns Zod number schema for weapon level validation
 */
declare function createDynamicWeaponLevelSchema(maxLevel: number): z.ZodNumber;

/**
 * Dynamic promote level validation schema factory (0 to maxPromoteLevel)
 * @param maxPromoteLevel Maximum promote level for character/weapon
 * @returns Zod number schema for promote level validation
 */
declare function createPromoteLevelSchema(maxPromoteLevel: number): z.ZodNumber;

/**
 * Range validation schema factory (min to max)
 */
declare function createRangeSchema(min: number, max: number, fieldName?: string): z.ZodNumber;

/**
 * Update interval validation schema factory (minInterval to maxInterval)
 */
declare function createUpdateIntervalSchema(minInterval: number, maxInterval?: number): z.ZodNumber;

/**
 * Common validation schemas for genshin-manager
 */
/**
 * Day of week validation schema (0-6)
 */
declare const dayOfWeekSchema: z.ZodNumber;
/**
 * Monster level validation schema (1-200)
 */
declare const monsterLevelSchema: z.ZodNumber;
/**
 * Player count validation schema (1-4)
 */
declare const playerCountSchema: z.ZodNumber;
/**
 * Weapon level validation schema (1-90)
 */
declare const weaponLevelSchema: z.ZodNumber;
/**
 * Character level validation schema (1-100)
 */
declare const characterLevelSchema: z.ZodNumber;
/**
 * Ascension level validation schema (0-6)
 */
declare const ascensionLevelSchema: z.ZodNumber;
/**
 * Refinement level validation schema (1-5)
 */
declare const refinementLevelSchema: z.ZodNumber;
/**
 * Constellation level validation schema (0-6)
 */
declare const constellationLevelSchema: z.ZodNumber;
/**
 * Skill level validation schema (1-15)
 */
declare const skillLevelSchema: z.ZodNumber;
/**
 * UID validation schema
 */
declare const uidSchema: z.ZodString;
/**
 * Traveler character ID validation schema
 */
declare const travelerIdSchema: z.ZodNumber;
/**
 * Fixed refinement rank validation schema (exactly 1)
 */
declare const fixedRefinementSchema: z.ZodNumber & z.ZodType<1, number, z.core.$ZodTypeInternals<1, number>>;
/**
 * File path validation schema
 */
declare const filePathSchema: z.ZodString;
/**
 * URL validation schema
 */
declare const urlSchema: z.ZodString;
/**
 * Asset ID validation schema
 */
declare const assetIdSchema: z.ZodString;
/**
 * Language code validation schema
 */
declare const languageCodeSchema: z.ZodEnum<{
    "en-us": "en-us";
    "ja-jp": "ja-jp";
    "ko-kr": "ko-kr";
    "zh-cn": "zh-cn";
    "zh-tw": "zh-tw";
    "de-de": "de-de";
    "es-es": "es-es";
    "fr-fr": "fr-fr";
    "id-id": "id-id";
    "pt-pt": "pt-pt";
    "ru-ru": "ru-ru";
    "th-th": "th-th";
    "vi-vn": "vi-vn";
}>;
/**
 * Character rarity validation schema (4-5 stars)
 */
declare const characterRaritySchema: z.ZodEnum<{
    4: "4";
    5: "5";
}>;
/**
 * Weapon rarity validation schema (1-5 stars)
 */
declare const weaponRaritySchema: z.ZodEnum<{
    1: "1";
    2: "2";
    3: "3";
    4: "4";
    5: "5";
}>;
/**
 * Element validation schema
 */
declare const elementSchema: z.ZodEnum<{
    Pyro: "Pyro";
    Electro: "Electro";
    Cryo: "Cryo";
    Anemo: "Anemo";
    Hydro: "Hydro";
    Geo: "Geo";
    Dendro: "Dendro";
}>;
/**
 * Weapon type validation schema
 */
declare const weaponTypeSchema: z.ZodEnum<{
    WEAPON_BOW: "WEAPON_BOW";
    WEAPON_CATALYST: "WEAPON_CATALYST";
    WEAPON_CLAYMORE: "WEAPON_CLAYMORE";
    WEAPON_POLE: "WEAPON_POLE";
    WEAPON_SWORD_ONE_HAND: "WEAPON_SWORD_ONE_HAND";
}>;
/**
 * Network configuration schema
 */
declare const networkConfigSchema: z.ZodObject<{
    timeout: z.ZodDefault<z.ZodNumber>;
    retries: z.ZodDefault<z.ZodNumber>;
    retryDelay: z.ZodDefault<z.ZodNumber>;
    userAgent: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
/**
 * Cache configuration schema
 */
declare const cacheConfigSchema: z.ZodObject<{
    enabled: z.ZodDefault<z.ZodBoolean>;
    ttl: z.ZodDefault<z.ZodNumber>;
    maxSize: z.ZodDefault<z.ZodNumber>;
    cleanupInterval: z.ZodDefault<z.ZodNumber>;
}, z.core.$strip>;
/**
 * Logging configuration schema
 */
declare const loggingConfigSchema: z.ZodObject<{
    level: z.ZodDefault<z.ZodEnum<{
        error: "error";
        warn: "warn";
        info: "info";
        debug: "debug";
    }>>;
    enabled: z.ZodDefault<z.ZodBoolean>;
    includeTimestamp: z.ZodDefault<z.ZodBoolean>;
    includeLevel: z.ZodDefault<z.ZodBoolean>;
}, z.core.$strip>;
/**
 * Asset processing configuration schema
 */
declare const assetProcessingConfigSchema: z.ZodObject<{
    downloadTimeout: z.ZodDefault<z.ZodNumber>;
    maxConcurrentDownloads: z.ZodDefault<z.ZodNumber>;
    retryFailedDownloads: z.ZodDefault<z.ZodBoolean>;
    verifyIntegrity: z.ZodDefault<z.ZodBoolean>;
}, z.core.$strip>;
/**
 * Main configuration schema
 */
declare const configSchema: z.ZodObject<{
    network: z.ZodOptional<z.ZodObject<{
        timeout: z.ZodDefault<z.ZodNumber>;
        retries: z.ZodDefault<z.ZodNumber>;
        retryDelay: z.ZodDefault<z.ZodNumber>;
        userAgent: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
    cache: z.ZodOptional<z.ZodObject<{
        enabled: z.ZodDefault<z.ZodBoolean>;
        ttl: z.ZodDefault<z.ZodNumber>;
        maxSize: z.ZodDefault<z.ZodNumber>;
        cleanupInterval: z.ZodDefault<z.ZodNumber>;
    }, z.core.$strip>>;
    logging: z.ZodOptional<z.ZodObject<{
        level: z.ZodDefault<z.ZodEnum<{
            error: "error";
            warn: "warn";
            info: "info";
            debug: "debug";
        }>>;
        enabled: z.ZodDefault<z.ZodBoolean>;
        includeTimestamp: z.ZodDefault<z.ZodBoolean>;
        includeLevel: z.ZodDefault<z.ZodBoolean>;
    }, z.core.$strip>>;
    assetProcessing: z.ZodOptional<z.ZodObject<{
        downloadTimeout: z.ZodDefault<z.ZodNumber>;
        maxConcurrentDownloads: z.ZodDefault<z.ZodNumber>;
        retryFailedDownloads: z.ZodDefault<z.ZodBoolean>;
        verifyIntegrity: z.ZodDefault<z.ZodBoolean>;
    }, z.core.$strip>>;
    dataDirectory: z.ZodOptional<z.ZodString>;
    language: z.ZodDefault<z.ZodEnum<{
        "en-us": "en-us";
        "ja-jp": "ja-jp";
        "ko-kr": "ko-kr";
        "zh-cn": "zh-cn";
        "zh-tw": "zh-tw";
        "de-de": "de-de";
        "es-es": "es-es";
        "fr-fr": "fr-fr";
        "id-id": "id-id";
        "pt-pt": "pt-pt";
        "ru-ru": "ru-ru";
        "th-th": "th-th";
        "vi-vn": "vi-vn";
    }>>;
}, z.core.$strip>;
/**
 * Export all schemas as a single object for easier imports
 */
declare const schemas: {
    createUpdateIntervalSchema: typeof createUpdateIntervalSchema;
    createPromoteLevelSchema: typeof createPromoteLevelSchema;
    createDynamicWeaponLevelSchema: typeof createDynamicWeaponLevelSchema;
    createArtifactLevelSchema: typeof createArtifactLevelSchema;
    weaponLevelSchema: z.ZodNumber;
    characterLevelSchema: z.ZodNumber;
    ascensionLevelSchema: z.ZodNumber;
    refinementLevelSchema: z.ZodNumber;
    constellationLevelSchema: z.ZodNumber;
    skillLevelSchema: z.ZodNumber;
    dayOfWeekSchema: z.ZodNumber;
    monsterLevelSchema: z.ZodNumber;
    playerCountSchema: z.ZodNumber;
    uidSchema: z.ZodString;
    travelerIdSchema: z.ZodNumber;
    fixedRefinementSchema: z.ZodNumber & z.ZodType<1, number, z.core.$ZodTypeInternals<1, number>>;
    filePathSchema: z.ZodString;
    urlSchema: z.ZodString;
    assetIdSchema: z.ZodString;
    languageCodeSchema: z.ZodEnum<{
        "en-us": "en-us";
        "ja-jp": "ja-jp";
        "ko-kr": "ko-kr";
        "zh-cn": "zh-cn";
        "zh-tw": "zh-tw";
        "de-de": "de-de";
        "es-es": "es-es";
        "fr-fr": "fr-fr";
        "id-id": "id-id";
        "pt-pt": "pt-pt";
        "ru-ru": "ru-ru";
        "th-th": "th-th";
        "vi-vn": "vi-vn";
    }>;
    characterRaritySchema: z.ZodEnum<{
        4: "4";
        5: "5";
    }>;
    weaponRaritySchema: z.ZodEnum<{
        1: "1";
        2: "2";
        3: "3";
        4: "4";
        5: "5";
    }>;
    elementSchema: z.ZodEnum<{
        Pyro: "Pyro";
        Electro: "Electro";
        Cryo: "Cryo";
        Anemo: "Anemo";
        Hydro: "Hydro";
        Geo: "Geo";
        Dendro: "Dendro";
    }>;
    weaponTypeSchema: z.ZodEnum<{
        WEAPON_BOW: "WEAPON_BOW";
        WEAPON_CATALYST: "WEAPON_CATALYST";
        WEAPON_CLAYMORE: "WEAPON_CLAYMORE";
        WEAPON_POLE: "WEAPON_POLE";
        WEAPON_SWORD_ONE_HAND: "WEAPON_SWORD_ONE_HAND";
    }>;
    networkConfigSchema: z.ZodObject<{
        timeout: z.ZodDefault<z.ZodNumber>;
        retries: z.ZodDefault<z.ZodNumber>;
        retryDelay: z.ZodDefault<z.ZodNumber>;
        userAgent: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>;
    cacheConfigSchema: z.ZodObject<{
        enabled: z.ZodDefault<z.ZodBoolean>;
        ttl: z.ZodDefault<z.ZodNumber>;
        maxSize: z.ZodDefault<z.ZodNumber>;
        cleanupInterval: z.ZodDefault<z.ZodNumber>;
    }, z.core.$strip>;
    loggingConfigSchema: z.ZodObject<{
        level: z.ZodDefault<z.ZodEnum<{
            error: "error";
            warn: "warn";
            info: "info";
            debug: "debug";
        }>>;
        enabled: z.ZodDefault<z.ZodBoolean>;
        includeTimestamp: z.ZodDefault<z.ZodBoolean>;
        includeLevel: z.ZodDefault<z.ZodBoolean>;
    }, z.core.$strip>;
    assetProcessingConfigSchema: z.ZodObject<{
        downloadTimeout: z.ZodDefault<z.ZodNumber>;
        maxConcurrentDownloads: z.ZodDefault<z.ZodNumber>;
        retryFailedDownloads: z.ZodDefault<z.ZodBoolean>;
        verifyIntegrity: z.ZodDefault<z.ZodBoolean>;
    }, z.core.$strip>;
    configSchema: z.ZodObject<{
        network: z.ZodOptional<z.ZodObject<{
            timeout: z.ZodDefault<z.ZodNumber>;
            retries: z.ZodDefault<z.ZodNumber>;
            retryDelay: z.ZodDefault<z.ZodNumber>;
            userAgent: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>;
        cache: z.ZodOptional<z.ZodObject<{
            enabled: z.ZodDefault<z.ZodBoolean>;
            ttl: z.ZodDefault<z.ZodNumber>;
            maxSize: z.ZodDefault<z.ZodNumber>;
            cleanupInterval: z.ZodDefault<z.ZodNumber>;
        }, z.core.$strip>>;
        logging: z.ZodOptional<z.ZodObject<{
            level: z.ZodDefault<z.ZodEnum<{
                error: "error";
                warn: "warn";
                info: "info";
                debug: "debug";
            }>>;
            enabled: z.ZodDefault<z.ZodBoolean>;
            includeTimestamp: z.ZodDefault<z.ZodBoolean>;
            includeLevel: z.ZodDefault<z.ZodBoolean>;
        }, z.core.$strip>>;
        assetProcessing: z.ZodOptional<z.ZodObject<{
            downloadTimeout: z.ZodDefault<z.ZodNumber>;
            maxConcurrentDownloads: z.ZodDefault<z.ZodNumber>;
            retryFailedDownloads: z.ZodDefault<z.ZodBoolean>;
            verifyIntegrity: z.ZodDefault<z.ZodBoolean>;
        }, z.core.$strip>>;
        dataDirectory: z.ZodOptional<z.ZodString>;
        language: z.ZodDefault<z.ZodEnum<{
            "en-us": "en-us";
            "ja-jp": "ja-jp";
            "ko-kr": "ko-kr";
            "zh-cn": "zh-cn";
            "zh-tw": "zh-tw";
            "de-de": "de-de";
            "es-es": "es-es";
            "fr-fr": "fr-fr";
            "id-id": "id-id";
            "pt-pt": "pt-pt";
            "ru-ru": "ru-ru";
            "th-th": "th-th";
            "vi-vn": "vi-vn";
        }>>;
    }, z.core.$strip>;
};

export { type APIAvatarInfo, type APIBuild, type APIBuildSettings, type APIEnkaPing, type APIEnkaPingu, type APIEnkaRegion, type APIEnkaStat, type APIEnkaStatus, type APIGameAccount, type APIOwner, type APIPlayerInfo, type APIProfile, type APIProfilePicture, type APIPropMap, type APIReliquary, type APIReliquaryEquip, type APIShowAvatarInfo, type APIWeapon, type APIWeaponEquip, AnnContentNotFoundError, Artifact, EquipType as ArtifactType, AssetCorruptedError, AssetDownloadFailedError, AssetError, AssetErrorFactory, AssetNotFoundError, AudioAssets, AudioNotFoundError, BodyNotFoundError, BodyType, type CVType, Character, CharacterAscension, CharacterBaseStats, CharacterConstellation, CharacterCostume, CharacterDetail, CharacterInfo, CharacterInherentSkill, CharacterPreview, CharacterProfile, CharacterSkill, CharacterSkillAscension, CharacterStatusManager, CharacterStory, CharacterVoice, Client, ClientEvents, type ClientOption, ConfigInvalidError, ConfigMissingError, DailyFarming, type DomainData, type Element, EnkaAccount, EnkaBuild, type EnkaData, EnkaManager, EnkaManagerEvents, EnkaNetworkError, EnkaNetworkStatusError, EnumValidationError, type ErrorCategory, type ErrorContext, ErrorContextFactory, type FightPropType, FormatValidationError, GeneralError, GenshinAccount, GenshinManagerError, GenshinManagerErrorCode, ImageAssets, ImageNotFoundError, ItemType$2 as ItemType, KeyMatchingError, LowConfidenceError, MasterFileConfigurationError, Material, MaterialType$1 as MaterialType, Monster, NetworkError, NetworkTimeoutError, NetworkUnavailableError, Notice, NoticeLanguage, NoticeManager, NoticeManagerEvents, PatternMismatchError, PlayerDetail, ProfilePicture, Type$2 as ProfilePictureType, QualityType, RangeValidationError, type Region, RequiredFieldError, type RetryConfiguration, StatProperty, TextMapFormatError, TimeZonesPerRegion, type URLParams, ValidationError, ValidationHelper, Weapon, WeaponAscension, WeaponInfo, WeaponRefinement, WeaponType, ascensionLevelSchema, assetIdSchema, assetProcessingConfigSchema, cacheConfigSchema, characterLevelSchema, characterRaritySchema, configSchema, constellationLevelSchema, convertToUTC, createArtifactLevelSchema, createDynamicWeaponLevelSchema, createPromoteLevelSchema, createRangeSchema, createUpdateIntervalSchema, dayOfWeekSchema, elementSchema, errorCategories, filePathSchema, fixedRefinementSchema, languageCodeSchema, loggingConfigSchema, monsterLevelSchema, networkConfigSchema, playerCountSchema, refinementLevelSchema, retryClassifications, schemas, skillLevelSchema, travelerIdSchema, uidSchema, urlSchema, weaponLevelSchema, weaponRaritySchema, weaponTypeSchema };