CoCalc is a real-time collaborative commercial alternative to JupyterHub and Overleaf that provides Jupyter Notebooks, LaTeX documents, and SageMath.

1
export interface gameData {
2
    academyTower:     AcademyTower[];
3
    ad:               Ad[];
4
    affix:            AffixElement[];
5
    atlas:            Atlas[];
6
    bgm:              BgmElement[];
7
    bitmapFont:       BitmapFont[];
8
    boots:            Boot[];
9
    boss:             BossElement[];
10
    bountyName:       BountyName[];
11
    bundle:           Bundle[];
12
    currency:         Currency[];
13
    dailyReward:      DailyReward[];
14
    dialogue:         Dialogue[];
15
    dorm:             Dorm[];
16
    dormbg:           Dormbg[];
17
    dungeon:          Dungeon[];
18
    emote:            Emote[];
19
    eyeColor:         Color[];
20
    face:             Face[];
21
    faceColor:        FaceColor[];
22
    follow:           Follow[];
23
    fontStyle:        FontStyle[];
24
    fossil:           Fossil[];
25
    fsm:              FSM[];
26
    gameFeed:         GameFeed[];
27
    gender:           Gender[];
28
    generic:          Generic[];
29
    giftBox:          GiftBox[];
30
    hair:             HairElement[];
31
    hairColor:        Color[];
32
    hat:              Hat[];
33
    item:             GameDataItem[];
34
    itemTable:        ItemTable[];
35
    key:              Key[];
36
    mathTownDecor:    MathTown[];
37
    mathTownFrame:    MathTown[];
38
    mathTownInterior: MathTownInterior[];
39
    mount:            Mount[];
40
    name:             NameElement[];
41
    nickname:         Nickname[];
42
    orb:              ORB[];
43
    outfit:           Outfit[];
44
    particleEffect:   GameDataParticleEffect[];
45
    pet:              Pet[];
46
    prizeWheel:       PrizeWheel[];
47
    relic:            Relic[];
48
    sfx:              Sfx[];
49
    singleImage:      SingleImage[];
50
    skinColor:        Face[];
51
    spell:            Spell[];
52
    spellRelic:       SpellRelic[];
53
    spine:            SpineElement[];
54
    streamedMap:      Atlas[];
55
    tiledMap:         Atlas[];
56
    tileset:          Tileset[];
57
    titan:            Titan[];
58
    ui:               UI[];
59
    weapon:           Weapon[];
60
}
61

62
export interface AcademyTower {
63
    ID:       number;
64
    assetID:  number;
65
    type:     string;
66
    gender:   number;
67
    data:     AcademyTowerData;
68
    metadata: MemberClass;
69
    name:     string;
70
}
71

72
export interface AcademyTowerData {
73
    enabled:                   boolean;
74
    name:                      string;
75
    towerID:                   string;
76
    element:                   EarthElement;
77
    minLevel:                  number;
78
    warden:                    WardenClass | string;
79
    towerEventName:            string;
80
    BGM:                       Bgm;
81
    wardenRoomKeyID:           number;
82
    saveWardenDialogueID?:     number;
83
    boss?:                     DataBoss;
84
    achievementMonsterIDs:     number[];
85
    battlesPerFloor:           number;
86
    battleBG:                  string;
87
    assets:                    string[];
88
    fsmIDs:                    FSMIDs;
89
    itemTableID:               number;
90
    floorConfigs?:             FloorConfig[];
91
    keystone:                  Keystone;
92
    afterKeyFoundDialogueIDs?: number[];
93
    betaPopup?:                BetaPopup;
94
    dialogueIds?:              any[];
95
    dungeonBGM?:               number;
96
    exitMap?:                  string;
97
    eventPrefix?:              string;
98
    floorGeneratorConfigs?:    { [key: string]: number };
99
}
100

101
export interface Bgm {
102
    dungeon:    number;
103
    incomplete: number;
104
    completed?: number;
105
    complete?:  number;
106
}
107

108
export interface BetaPopup {
109
    prefabID:              number;
110
    cooldownTimeInSeconds: number;
111
}
112

113
export interface DataBoss {
114
    tmxName:          string;
115
    ID:               number;
116
    attacks:          number[];
117
    localizedTextRef: string;
118
    difficulty:       number;
119
    maxHP:            null;
120
    spineKey:         string;
121
    battleBG:         string;
122
}
123

124
export enum EarthElement {
125
    Astral = "astral",
126
    Earth = "earth",
127
    Empty = "",
128
    Fire = "fire",
129
    Ice = "ice",
130
    IceFire = "ice & fire",
131
    Mech = "mech",
132
    Plant = "plant",
133
    Shadow = "shadow",
134
    Special = "special",
135
    Storm = "storm",
136
    Water = "water",
137
    Wizard = "wizard",
138
}
139

140
export interface FloorConfig {
141
    generator:   number;
142
    dialogueIDs: number[];
143
}
144

145
export interface FSMIDs {
146
    intro:      number;
147
    bossBattle: number;
148
    freeWarden: number;
149
}
150

151
export interface Keystone {
152
    zone:                string;
153
    x:                   number;
154
    y:                   number;
155
    itemID:              number;
156
    unlockedDialogueID?: number;
157
}
158

159
export interface WardenClass {
160
    name:             string;
161
    spine:            string;
162
    atlas:            string;
163
    localizedTextRef: string;
164
    freedDialogueIDs: number[];
165
    flipSpine:        boolean;
166
    offset:           BeijingPigeon;
167
    nameTextPos:      BeijingPigeon;
168
    bubbleAnimName?:  string;
169
    bubblePopName?:   string;
170
}
171

172
export interface BeijingPigeon {
173
    x: number;
174
    y: number;
175
}
176

177
export interface MemberClass {
178
}
179

180
export interface Ad {
181
    ID:       number;
182
    assetID:  number;
183
    type:     AdType;
184
    gender:   number;
185
    data:     AdData;
186
    metadata: MemberClass;
187
    name:     string;
188
}
189

190
export interface AdData {
191
    name:                  string;
192
    sendDate:              null | string;
193
    startDate?:            null | string;
194
    expiryDate:            null | string;
195
    prefabID?:             number;
196
    assets?:               string[];
197
    priority?:             number;
198
    title?:                string;
199
    body?:                 string;
200
    travelZone?:           string;
201
    travelConfirmMessage?: string;
202
    thumbnail?:            number;
203
    uiID?:                 number;
204
    dateTextName?:         string;
205
    buttons?:              Button[];
206
    testLanes?:            number[];
207
    experimentTrackEvent?: string;
208
    videoMessageTitle?:    string;
209
    videoMessage?:         string;
210
    videoID?:              string;
211
    memberSuppression?:    boolean;
212
    optimizely?:           Optimizely;
213
    filename?:             string;
214
}
215

216
export interface Button {
217
    name:             ButtonName;
218
    method:           string;
219
    parameters?:      Array<number | null | string>;
220
    showOnStartDate?: boolean;
221
}
222

223
export enum ButtonName {
224
    Empty = "",
225
    GoNowButton = "goNowButton",
226
    PlayVideoButton = "playVideoButton",
227
    WatchVideoButton = "watchVideoButton",
228
}
229

230
export interface Optimizely {
231
    feature:   string;
232
    variable?: string;
233
}
234

235
export enum AdType {
236
    Ad = "ad",
237
}
238

239
export interface AffixElement {
240
    ID:       number;
241
    assetID:  number;
242
    type:     FluffyType;
243
    gender:   number;
244
    data:     AffixData;
245
    metadata: PurpleMetadata;
246
    name:     string;
247
}
248

249
export interface AffixData {
250
    label?:         string;
251
    opType?:        number;
252
    type:           string;
253
    value?:         number;
254
    name:           string;
255
    valuePercent?:  number;
256
    amount?:        number;
257
    operationType?: number;
258
    version?:       number;
259
    elements?:      EarthElement[];
260
    highPotency?:   boolean;
261
}
262

263
export interface PurpleMetadata {
264
    v?:         number;
265
    type?:      PurpleType;
266
    vIcon?:     number;
267
    assets?:    PurpleAssets;
268
    subType?:   number;
269
    faceColor?: number;
270
}
271

272
export interface PurpleAssets {
273
    default?: PurpleDefault;
274
    male?:    Male;
275
    female?:  Female;
276
}
277

278
export interface PurpleDefault {
279
    type:   PurpleType;
280
    v:      number;
281
    offSet: BeijingPigeon;
282
}
283

284
export enum PurpleType {
285
    Atlas = "atlas",
286
    Multiple = "multiple",
287
    SingleImage = "singleImage",
288
}
289

290
export interface Female {
291
    v:              number;
292
    legs:           LeftArm;
293
    type:           PurpleType;
294
    shirt:          LeftArm;
295
    leftArm:        LeftArm;
296
    rightArm:       LeftArm;
297
    leg?:           BeijingPigeon;
298
    iconVersions?:  Version[];
299
    assetVersions?: Version[];
300
    noCache?:       boolean;
301
}
302

303
export interface Version {
304
    id: string;
305
}
306

307
export interface LeftArm {
308
    x:       number;
309
    y:       number;
310
    pivot:   BeijingPigeon;
311
    handIK?: BeijingPigeon;
312
}
313

314
export interface Male {
315
    v:              number;
316
    legs:           Legs;
317
    type:           PurpleType;
318
    shirt:          LeftArm;
319
    leftArm:        LeftArm;
320
    rightArm:       LeftArm;
321
    leg?:           BeijingPigeon;
322
    iconVersions?:  Version[];
323
    assetVersions?: Version[];
324
    noCache?:       boolean;
325
}
326

327
export interface Legs {
328
    x:     number;
329
    y:     number;
330
    pivot: Pivot;
331
}
332

333
export interface Pivot {
334
    x: number;
335
    y: number | string;
336
}
337

338
export enum FluffyType {
339
    Affix = "affix",
340
}
341

342
export interface Atlas {
343
    ID:       number;
344
    assetID:  number;
345
    type:     AtlasType;
346
    gender:   number;
347
    data:     AtlasData;
348
    metadata: AtlasMetadata;
349
    name:     string;
350
}
351

352
export interface AtlasData {
353
    filename: string;
354
    name?:    string;
355
}
356

357
export interface AtlasMetadata {
358
    assets: FluffyAssets;
359
}
360

361
export interface FluffyAssets {
362
    default: FluffyDefault;
363
}
364

365
export interface FluffyDefault {
366
    v: number;
367
}
368

369
export enum AtlasType {
370
    Atlas = "atlas",
371
    StreamedMap = "streamedMap",
372
    TiledMap = "tiledMap",
373
}
374

375
export interface BgmElement {
376
    ID:       number;
377
    assetID:  number;
378
    type:     BgmType;
379
    gender:   number;
380
    data:     AtlasData;
381
    metadata: BgmMetadata;
382
    name:     string;
383
}
384

385
export interface BgmMetadata {
386
    assets: FluffyAssets;
387
    v?:     number;
388
}
389

390
export enum BgmType {
391
    Bgm = "bgm",
392
}
393

394
export interface BitmapFont {
395
    ID:       number;
396
    assetID:  number;
397
    type:     string;
398
    gender:   number;
399
    data:     BitmapFontData;
400
    metadata: AtlasMetadata;
401
    name:     string;
402
}
403

404
export interface BitmapFontData {
405
    filename: string;
406
}
407

408
export interface Boot {
409
    ID:       number;
410
    assetID:  number;
411
    type:     TypeElement;
412
    gender:   number;
413
    data:     BootData;
414
    metadata: PurpleMetadata;
415
    name:     string;
416
}
417

418
export interface BootData {
419
    drop?:      number;
420
    name:       string;
421
    price?:     number;
422
    member:     number;
423
    rarity:     number;
424
    effects:    Array<number | string>;
425
    flavorText: string;
426
    cost?:      CostElement[];
427
    ""?:        string;
428
    "0"?:       number;
429
    "en-us"?:   string;
430
    type?:      TentacledType;
431
    memberAd?:  number;
432
}
433

434
export interface CostElement {
435
    type:            TypeElement;
436
    ID:              number;
437
    N?:              number;
438
    dropChance?:     number;
439
    duplicateValue?: number;
440
}
441

442
export enum TypeElement {
443
    Boots = "boots",
444
    Currency = "currency",
445
    Dorm = "dorm",
446
    Empty = "",
447
    Follow = "follow",
448
    Fossil = "fossil",
449
    GiftBox = "giftBox",
450
    Gold = "gold",
451
    Hat = "hat",
452
    Item = "item",
453
    ORB = "orb",
454
    Outfit = "outfit",
455
    Prefab = "prefab",
456
    Weapon = "weapon",
457
}
458

459
export enum TentacledType {
460
    Cover = "cover",
461
    Empty = "",
462
    Hat = "Hat",
463
    Mask = "mask",
464
    Wrap = "wrap",
465
}
466

467
export interface BossElement {
468
    ID:       number;
469
    assetID:  number;
470
    type:     BossType;
471
    gender:   number;
472
    data:     BossData;
473
    metadata: BossMetadata;
474
    name:     string;
475
}
476

477
export interface BossData {
478
    name?:               string;
479
    nameKey?:            string;
480
    element?:            AstralElement;
481
    adventureRewards?:   AdventureReward[];
482
    battleCheckpointID?: number;
483
    battle?:             Battle;
484
    rockShuffle?:        { [key: string]: RockShuffle };
485
    creatureModifiers?:  CreatureModifiers;
486
    tree?:               Tree;
487
    spiderBattle?:       SpiderBattle;
488
    wizard?:             Wizard;
489
    lootTableID?:        number;
490
    missCooldown?:       number;
491
    powerStat?:          number;
492
    healthStat?:         number;
493
    spells?:             number[];
494
    affixIDs?:           number[];
495
    relicRingReward?:    number;
496
    starReward?:         number;
497
    specialSpells?:      SpecialSpell[];
498
    unsecureRewards?:    UnsecureReward[];
499
}
500

501
export interface AdventureReward {
502
    type: TypeElement;
503
    ID:   number;
504
}
505

506
export interface Battle {
507
    hpStat:                       number;
508
    powerStat?:                   number;
509
    wyrmAttacks?:                 number[];
510
    rockAttacks?:                 number[];
511
    difficulty:                   number;
512
    phaseHPThresholdPercentage?:  number;
513
    undergroundDamageMultiplier?: number;
514
    damageModifier?:              number;
515
    hpModifier?:                  number;
516
    attacks?:                     number[] | AttacksClass;
517
    health?:                      number;
518
    castDelay?:                   number;
519
    yetiAttacks?:                 number[];
520
    spiderAttacks?:               number[];
521
    battleShy?:                   boolean;
522
}
523

524
export interface AttacksClass {
525
    fire:   number[];
526
    water:  number[];
527
    plant:  number[];
528
    ice:    number[];
529
    storm:  number[];
530
    shadow: number[];
531
}
532

533
export interface CreatureModifiers {
534
    damage: number;
535
}
536

537
export enum AstralElement {
538
    Astral = "astral",
539
    Ice = "ice",
540
    Shadow = "shadow",
541
}
542

543
export interface RockShuffle {
544
    timeElapsed:  DelayClass;
545
    delay:        DelayClass;
546
    shuffleCount: UnitLevel;
547
}
548

549
export interface DelayClass {
550
    start: number;
551
    end:   number;
552
}
553

554
export interface UnitLevel {
555
    min: number;
556
    max: number;
557
}
558

559
export interface SpecialSpell {
560
    id:       number;
561
    cooldown: number;
562
}
563

564
export interface SpiderBattle {
565
    minTeamSize:      number;
566
    scale:            boolean;
567
    pets:             Particles[];
568
    walkIntoBattle:   boolean;
569
    targetingEnabled: boolean;
570
    catch:            boolean;
571
    adventureRewards: AdventureReward[];
572
}
573

574
export interface Particles {
575
    ID: number;
576
}
577

578
export interface Tree {
579
    creature:        Creature;
580
    hpStat:          number;
581
    breakThresholds: number[];
582
}
583

584
export interface Creature {
585
    element: AstralElement;
586
}
587

588
export interface UnsecureReward {
589
    type:             TypeElement;
590
    ID:               number;
591
    minAmountPresent: number;
592
}
593

594
export interface Wizard {
595
    appearance: Appearance;
596
    equipment:  Equipment;
597
}
598

599
export interface Appearance {
600
    gender:    string;
601
    hair:      AppearanceHair;
602
    skinColor: number;
603
    eyeColor:  number;
604
    face:      number;
605
}
606

607
export interface AppearanceHair {
608
    style: number;
609
    color: number;
610
}
611

612
export interface Equipment {
613
    hat:        number;
614
    outfit:     number;
615
    weapon:     number;
616
    spellRelic: number;
617
}
618

619
export interface BossMetadata {
620
    assets: TentacledAssets;
621
    type?:  PurpleType;
622
}
623

624
export interface TentacledAssets {
625
    type?:   PurpleType;
626
    default: TentacledDefault;
627
}
628

629
export interface TentacledDefault {
630
    type?:           AssetTypeEnum;
631
    x?:              number;
632
    w?:              number;
633
    h?:              number;
634
    v?:              number;
635
    hitbox?:         DefaultHitbox;
636
    filename?:       string;
637
    ID?:             number;
638
    rootOffset?:     BeijingPigeon;
639
    secondarySpine?: SecondarySpine;
640
}
641

642
export interface DefaultHitbox {
643
    width:    number;
644
    height:   number;
645
    xOffset:  number;
646
    yOffset?: number;
647
}
648

649
export interface SecondarySpine {
650
    ID: number;
651
    v:  number;
652
}
653

654
export enum AssetTypeEnum {
655
    Atlas = "atlas",
656
    Spine = "spine",
657
    Spritesheet = "spritesheet",
658
}
659

660
export enum BossType {
661
    Boss = "boss",
662
}
663

664
export interface BountyName {
665
    ID:       number;
666
    assetID:  number;
667
    type:     BountyNameType;
668
    gender:   number;
669
    data:     BountyNameData;
670
    metadata: MemberClass;
671
    name:     string;
672
}
673

674
export interface BountyNameData {
675
    name:           string;
676
    value:          string;
677
    templateType:   TemplateType;
678
    requiredPetIDs: number[];
679
}
680

681
export enum TemplateType {
682
    PetName = "pet-name",
683
}
684

685
export enum BountyNameType {
686
    BountyName = "bountyName",
687
}
688

689
export interface Bundle {
690
    ID:       number;
691
    assetID:  number;
692
    type:     string;
693
    gender:   number;
694
    data:     BundleData;
695
    metadata: BundleMetadata;
696
    name:     string;
697
}
698

699
export interface BundleData {
700
    name:           string;
701
    isPurchaseable: boolean;
702
    price:          number;
703
    items:          CostElement[];
704
    flavorText:     string;
705
}
706

707
export interface BundleMetadata {
708
    vIcon: number;
709
}
710

711
export interface Currency {
712
    ID:       number;
713
    assetID:  number;
714
    type:     TypeElement;
715
    gender:   number;
716
    data:     CurrencyData;
717
    metadata: PurpleMetadata;
718
    name:     string;
719
}
720

721
export interface CurrencyData {
722
    drop:        number;
723
    name:        string;
724
    price:       number;
725
    modifier:    number;
726
    flavorText:  string;
727
    icon?:       null | string;
728
    namePlural?: string;
729
    zone?:       Zone;
730
    cost?:       CostElement[] | CostElement;
731
}
732

733
export enum Zone {
734
    Any = "any",
735
    Empty = "",
736
}
737

738
export interface DailyReward {
739
    ID:       number;
740
    assetID:  number;
741
    type:     string;
742
    gender:   number;
743
    data:     DailyRewardData;
744
    metadata: MemberClass;
745
    name:     string;
746
}
747

748
export interface DailyRewardData {
749
    resetDayIndex: number;
750
    days:          Day[];
751
    name:          string;
752
}
753

754
export interface Day {
755
    numRequiredQuestions: number;
756
    rewards:              CostElement[];
757
}
758

759
export interface Dialogue {
760
    ID:       number;
761
    assetID:  number;
762
    type:     DialogueType;
763
    gender:   number;
764
    data:     DialogueData;
765
    metadata: MemberClass;
766
    name:     string;
767
}
768

769
export interface DialogueData {
770
    audio:     Audio;
771
    avatar:    Avatar;
772
    textKey:   string;
773
    nameKey?:  string;
774
    nameKKey?: string;
775
    name?:     string;
776
}
777

778
export interface Audio {
779
    d?:   number;
780
    s?:   number;
781
    tag?: string;
782
}
783

784
export interface Avatar {
785
    atlas?:          string;
786
    frameName:       FrameName;
787
    animationMod:    number | null | string;
788
    spineAttachment: null | string;
789
    dimmed?:         boolean;
790
    offsetY?:        number;
791
}
792

793
export enum FrameName {
794
    Empty = "",
795
    Face0 = "face_0",
796
    Face1 = "face_1",
797
    Face10 = "face_10",
798
    Face15 = "face_15",
799
    Face2 = "face_2",
800
    Face3 = "face_3",
801
    Face4 = "face_4",
802
    Face5 = "face_5",
803
    Face6 = "face_6",
804
    Face7 = "face_7",
805
    Face8 = "face_8",
806
    Face9 = "face_9",
807
}
808

809
export enum DialogueType {
810
    Dialogue = "dialogue",
811
}
812

813
export interface Dorm {
814
    ID:       number;
815
    assetID:  number;
816
    type:     TypeElement;
817
    gender:   number;
818
    data:     DormData;
819
    metadata: DormMetadata;
820
    name:     string;
821
}
822

823
export interface DormData {
824
    r:          number;
825
    name:       string;
826
    price:      number;
827
    member:     number;
828
    rarity:     number;
829
    category:   Category;
830
    flavorText: string;
831
    cost?:      CostElement[];
832
    "en-us"?:   string;
833
}
834

835
export enum Category {
836
    Comfy = "Comfy",
837
    Items = "Items",
838
    Lamps = "Lamps",
839
    Plants = "Plants",
840
    Storage = "Storage",
841
    Surface = "Surface",
842
    Wall = "Wall",
843
}
844

845
export interface DormMetadata {
846
    type:       StickyType;
847
    vIcon:      number;
848
    assets:     StickyAssets;
849
    v?:         number;
850
    iconAtlas?: string;
851
}
852

853
export interface StickyAssets {
854
    vertical:    Vertical;
855
    horizontal?: Horizontal;
856
    sheets?:     Sheets;
857
}
858

859
export interface Horizontal {
860
    v:       number;
861
    type:    HorizontalType;
862
    anchor?: BeijingPigeon;
863
}
864

865
export enum HorizontalType {
866
    Atlas = "atlas",
867
    SingleImage = "singleImage",
868
    Spine = "spine",
869
}
870

871
export interface Sheets {
872
    v:    number;
873
    type: PurpleType;
874
}
875

876
export interface Vertical {
877
    v?:        number;
878
    type?:     HorizontalType;
879
    anchor?:   BeijingPigeon;
880
    animated?: boolean;
881
    noCache?:  boolean;
882
    ID?:       number;
883
}
884

885
export enum StickyType {
886
    Multiple = "multiple",
887
    Spine = "spine",
888
}
889

890
export interface Dormbg {
891
    ID:       number;
892
    assetID:  number;
893
    type:     DormbgType;
894
    gender:   number;
895
    data:     DormbgData;
896
    metadata: BundleMetadata;
897
    name:     string;
898
}
899

900
export interface DormbgData {
901
    x:          number;
902
    y:          number;
903
    tag:        string;
904
    name:       string;
905
    price:      number;
906
    member:     number;
907
    rarity:     number;
908
    category:   Category;
909
    flavorText: string;
910
}
911

912
export enum DormbgType {
913
    Dormbg = "dormbg",
914
}
915

916
export interface Dungeon {
917
    ID:       number;
918
    assetID:  number;
919
    type:     DungeonType;
920
    gender:   number;
921
    data:     DungeonData;
922
    metadata: MemberClass;
923
    name:     string;
924
}
925

926
export interface DungeonData {
927
    version:           number;
928
    name:              string;
929
    seed:              null;
930
    gridWidth:         number;
931
    gridHeight:        number;
932
    minCritPathLength: number;
933
    maxCritPathLength: number;
934
    monsterIDs:        number[];
935
    minEncounters:     number;
936
    maxEncounters:     number;
937
    monsterDrops:      CostElement[];
938
    goldenPages:       number;
939
    minPages:          number;
940
    maxPages:          number;
941
    battleDifficulty:  number;
942
    extraPaths:        ExtraPaths;
943
    monsterRooms:      Room[];
944
    normalRooms:       Room[];
945
    endRoom:           Room;
946
    monsterWeights?:   number[];
947
}
948

949
export interface Room {
950
    tileMap: string;
951
    fsmId:   number;
952
}
953

954
export interface ExtraPaths {
955
    minLength: number;
956
    maxLength: number;
957
    minPaths:  number;
958
    maxPaths:  number;
959
}
960

961
export enum DungeonType {
962
    Dungeon = "dungeon",
963
}
964

965
export interface Emote {
966
    ID:       number;
967
    assetID:  number;
968
    type:     EmoteType;
969
    gender:   number;
970
    data:     EmoteData;
971
    metadata: PurpleMetadata;
972
    name:     string;
973
}
974

975
export interface EmoteData {
976
    name:       string;
977
    isAnimated: number;
978
}
979

980
export enum EmoteType {
981
    Emote = "emote",
982
}
983

984
export interface Color {
985
    ID:       number;
986
    assetID:  number;
987
    type:     EyeColorType;
988
    gender:   number;
989
    data:     EyeColorData;
990
    metadata: PurpleMetadata;
991
    name:     string;
992
}
993

994
export interface EyeColorData {
995
    name:        string;
996
    price:       number;
997
    colors?:     Array<number[]>;
998
    member:      number;
999
    flavorText?: string;
1000
}
1001

1002
export enum EyeColorType {
1003
    EyeColor = "eyeColor",
1004
    HairColor = "hairColor",
1005
}
1006

1007
export interface Face {
1008
    ID:       number;
1009
    assetID:  number;
1010
    type:     FaceType;
1011
    gender:   number;
1012
    data:     FaceData;
1013
    metadata: PurpleMetadata;
1014
    name:     FaceName;
1015
}
1016

1017
export interface FaceData {
1018
    price:      number;
1019
    name:       string;
1020
    flavorText: FlavorText;
1021
    colors?:    Array<number[]>;
1022
}
1023

1024
export enum FlavorText {
1025
    BuyingThisWillChangeYourFaceStyle = "Buying this will change your face style!",
1026
    BuyingThisWillChangeYourSkinTone = "Buying this will change your skin tone!",
1027
    FlavorTextBuyingThisWillChangeYourFaceStyle = "Buying this will change your face style.",
1028
}
1029

1030
export enum FaceName {
1031
    Empty = "",
1032
    Face17 = "Face-17",
1033
    Face18 = "Face-18",
1034
}
1035

1036
export enum FaceType {
1037
    Face = "face",
1038
    SkinColor = "skinColor",
1039
}
1040

1041
export interface FaceColor {
1042
    ID:       number;
1043
    assetID:  number;
1044
    type:     string;
1045
    gender:   number;
1046
    data:     FaceColorData;
1047
    metadata: MemberClass;
1048
    name:     string;
1049
}
1050

1051
export interface FaceColorData {
1052
    price:  number;
1053
    colors: Array<number[]>;
1054
}
1055

1056
export interface Follow {
1057
    ID:       number;
1058
    assetID:  number;
1059
    type:     TypeElement;
1060
    gender:   number;
1061
    data:     FollowData;
1062
    metadata: FollowMetadata;
1063
    name:     string;
1064
}
1065

1066
export interface FollowData {
1067
    tag?:                string;
1068
    name:                string;
1069
    price?:              number;
1070
    member?:             number;
1071
    rarity:              number;
1072
    flavorText:          string;
1073
    customPrice?:        number;
1074
    spriteOffsets?:      SpriteOffsets;
1075
    numWalkAnimFrames?:  number;
1076
    numStandAnimFrames?: number;
1077
    drop?:               number;
1078
    particleEffects?:    DataParticleEffect[];
1079
    cost?:               CostElement[];
1080
    "en-us"?:            string;
1081
}
1082

1083
export interface DataParticleEffect {
1084
    ID:       number;
1085
    x:        number;
1086
    y:        number;
1087
    inFront?: boolean;
1088
}
1089

1090
export interface SpriteOffsets {
1091
    body?: BeijingPigeon;
1092
    tail?: BeijingPigeon;
1093
    legs?: BeijingPigeon;
1094
}
1095

1096
export interface FollowMetadata {
1097
    assets?: IndigoAssets;
1098
    v?:      number;
1099
    type:    NameEnum;
1100
    vIcon:   number;
1101
    icon?:   string;
1102
    petID?:  number;
1103
    anchor?: BeijingPigeon;
1104
}
1105

1106
export interface IndigoAssets {
1107
    default: Vertical;
1108
    prefab?: Prefab;
1109
}
1110

1111
export interface Prefab {
1112
    type:    TypeElement;
1113
    ID:      number;
1114
    hitbox?: PrefabHitbox;
1115
}
1116

1117
export interface PrefabHitbox {
1118
    x:      number;
1119
    y:      number;
1120
    width:  number;
1121
    height: number;
1122
}
1123

1124
export enum NameEnum {
1125
    Legacy = "legacy",
1126
    Pet = "pet",
1127
    Spine = "spine",
1128
}
1129

1130
export interface FontStyle {
1131
    ID:       number;
1132
    assetID:  number;
1133
    type:     FontStyleType;
1134
    gender:   number;
1135
    data:     FontStyleData;
1136
    metadata: MemberClass;
1137
    name:     string;
1138
}
1139

1140
export interface FontStyleData {
1141
    font:             string;
1142
    fontSize:         number;
1143
    fontWeight?:      string;
1144
    smoothed:         boolean;
1145
    fill:             string;
1146
    blendMode?:       number;
1147
    padding?:         BeijingPigeon;
1148
    stroke?:          string;
1149
    strokeThickness?: number;
1150
    shadowDistance?:  number;
1151
    shadowColor?:     string;
1152
    shadowBlur?:      number;
1153
    name?:            string;
1154
}
1155

1156
export enum FontStyleType {
1157
    FontStyle = "fontStyle",
1158
}
1159

1160
export interface Fossil {
1161
    ID:       number;
1162
    assetID:  number;
1163
    type:     TypeElement;
1164
    gender:   number;
1165
    data:     FossilData;
1166
    metadata: BundleMetadata;
1167
    name:     string;
1168
}
1169

1170
export interface FossilData {
1171
    name:       string;
1172
    count?:     number;
1173
    price:      number;
1174
    rarity:     number;
1175
    flavorText: string;
1176
    recipe?:    CostElement[];
1177
}
1178

1179
export interface FSM {
1180
    ID:       number;
1181
    assetID:  number;
1182
    type:     FSMType;
1183
    gender:   number;
1184
    data:     FSMData;
1185
    metadata: MemberClass;
1186
    name:     string;
1187
}
1188

1189
export interface FSMData {
1190
    version: number;
1191
    name?:   string;
1192
    states:  State[];
1193
    names?:  string;
1194
}
1195

1196
export interface State {
1197
    name?:        string;
1198
    actions:      ActionElement[];
1199
    transitions?: Transition[];
1200
}
1201

1202
export interface ActionElement {
1203
    type:       string;
1204
    parameters: Parameters;
1205
    results?:   Results;
1206
    wait?:      boolean;
1207
}
1208

1209
export interface Parameters {
1210
    enable?:                 boolean;
1211
    function?:               string;
1212
    context?:                string;
1213
    arguments?:              Array<boolean | number | string>;
1214
    time?:                   number | string;
1215
    creature?:               string;
1216
    ID?:                     number[] | number;
1217
    clip?:                   string;
1218
    pack?:                   string;
1219
    sound?:                  string;
1220
    character?:              Character;
1221
    target?:                 BeijingPigeon | string;
1222
    visible?:                boolean;
1223
    pathfinder?:             Path;
1224
    x?:                      number | null | string;
1225
    y?:                      number | null | string;
1226
    height?:                 number;
1227
    xOffset?:                number;
1228
    wait?:                   boolean | string;
1229
    walkSpeed?:              number;
1230
    eventName?:              EventName;
1231
    eventData?:              EventData;
1232
    overlayMode?:            boolean;
1233
    player?:                 string;
1234
    flag?:                   boolean;
1235
    name?:                   string;
1236
    value?:                  boolean | number | string;
1237
    variables?:              Variables;
1238
    screen?:                 string;
1239
    hide?:                   boolean;
1240
    items?:                  ItemsItem[] | string;
1241
    element?:                string;
1242
    show?:                   boolean;
1243
    yOffset?:                number;
1244
    delay?:                  number | string;
1245
    intensity?:              number;
1246
    direction?:              string;
1247
    path?:                   BeijingPigeon[];
1248
    speed?:                  number | null;
1249
    alpha?:                  number;
1250
    type?:                   ParametersType;
1251
    properties?:             EventData;
1252
    game?:                   Game;
1253
    breadcrumbName?:         string;
1254
    featureName?:            string;
1255
    spine?:                  string;
1256
    animationName?:          string;
1257
    map?:                    DefeatZone;
1258
    loadingData?:            LoadingData;
1259
    zone?:                   string;
1260
    quest?:                  number;
1261
    sequence?:               number | string;
1262
    config?:                 Config;
1263
    positions?:              BeijingPigeon[];
1264
    animation?:              Animation;
1265
    layer?:                  Layer;
1266
    randomDelay?:            boolean;
1267
    fadeIn?:                 number;
1268
    loop?:                   boolean;
1269
    to?:                     To[];
1270
    parent?:                 string;
1271
    animationChain?:         string[];
1272
    scene?:                  string;
1273
    state?:                  number | string;
1274
    active?:                 boolean;
1275
    animationClip?:          string;
1276
    transform?:              string;
1277
    position?:               string;
1278
    animationController?:    string;
1279
    data?:                   string;
1280
    defeatZone?:             DefeatZone;
1281
    rocks?:                  string;
1282
    shuffleCount?:           string;
1283
    startTimeElapsed?:       string;
1284
    endTimeElapsed?:         string;
1285
    startDelay?:             string;
1286
    endDelay?:               string;
1287
    controller?:             string;
1288
    service?:                string;
1289
    externalFactory?:        string;
1290
    bossID?:                 string;
1291
    bossSeenID?:             string;
1292
    locomotion?:             string;
1293
    createParent?:           boolean;
1294
    xScale?:                 number;
1295
    yScale?:                 number;
1296
    componentType?:          string;
1297
    playerIdentifier?:       string;
1298
    duration?:               number | string;
1299
    object?:                 string;
1300
    animator?:               string;
1301
    component?:              string;
1302
    text?:                   string;
1303
    playerObject?:           string;
1304
    graphic?:                string;
1305
    from?:                   string;
1306
    prefabLoader?:           string;
1307
    count?:                  string;
1308
    offset?:                 string;
1309
    playDuration?:           string;
1310
    fadeDuration?:           number;
1311
    saveEnabled?:            boolean;
1312
    faceTransform?:          string;
1313
    reenableInputOnClose?:   boolean;
1314
    cameraTransform?:        string;
1315
    targetTransform?:        string;
1316
    cameraFollowController?: string;
1317
    enableFollowController?: boolean;
1318
    renderComponent?:        string;
1319
    durationMS?:             DurationMSEnum | number;
1320
    targetAlpha?:            number;
1321
    rectTransform?:          string;
1322
    initialAlpha?:           number;
1323
    scaleTimeMS?:            number;
1324
    correctionAmounts?:      number[];
1325
    correctionTimes?:        number[];
1326
}
1327

1328
export enum Animation {
1329
    Idle = "idle",
1330
    Lantern1Glow = "lantern-1-glow",
1331
    Lantern2Glow = "lantern-2-glow",
1332
}
1333

1334
export enum Character {
1335
    Florian = "florian",
1336
    Gale = "gale",
1337
    Merchant = "merchant",
1338
    Noot = "noot",
1339
    Pippet = "pippet",
1340
    Puppetmaster = "puppetmaster",
1341
}
1342

1343
export enum Config {
1344
    GoldenPageConfig = "$goldenPageConfig",
1345
    MonsterConfig = "$monsterConfig",
1346
    PageConfig = "$pageConfig",
1347
}
1348

1349
export enum DefeatZone {
1350
    AcademyCR2 = "academy-CR2",
1351
    AcademyGH1 = "academy-GH1",
1352
    AcademyGH2 = "academy-GH2",
1353
    AcademyGH3 = "academy-GH3",
1354
    EarthtowerCR = "earthtower-CR",
1355
    EarthtowerWR = "earthtower-WR",
1356
    HouseExterior = "house-exterior",
1357
    IcetowerCR = "icetower-CR",
1358
    IcetowerWR = "icetower-WR",
1359
    LamplightB3 = "lamplight-B3",
1360
    Map = "$map",
1361
    ReturnMap = "$returnMap",
1362
    TowerTownA0 = "tower_town-A0",
1363
}
1364

1365
export enum DurationMSEnum {
1366
    BannerShowTimeMS = "$bannerShowTimeMS",
1367
    CardFadeDuration = "$cardFadeDuration",
1368
}
1369

1370
export interface EventData {
1371
    type: EventDataType;
1372
    name: string;
1373
}
1374

1375
export enum EventDataType {
1376
    AcademyArchives = "AcademyArchives",
1377
    Tutorial2 = "tutorial_2",
1378
    TutorialSteps1 = "tutorial_steps_1",
1379
}
1380

1381
export enum EventName {
1382
    GameComplete = "game_complete",
1383
}
1384

1385
export enum Game {
1386
    Game = "$game",
1387
}
1388

1389
export interface ItemsItem {
1390
    type:  string;
1391
    ID:    number;
1392
    data?: PurpleData;
1393
}
1394

1395
export interface PurpleData {
1396
    level: number;
1397
    stars: number;
1398
}
1399

1400
export enum Layer {
1401
    Content = "content",
1402
}
1403

1404
export interface LoadingData {
1405
    fadeIn:  boolean;
1406
    time:    number;
1407
    fadeOut: boolean;
1408
}
1409

1410
export enum Path {
1411
    Path = "$path",
1412
    Pathfinder = "$pathfinder",
1413
    PlayerPathfinder = "$playerPathfinder",
1414
}
1415

1416
export interface To {
1417
    properties: Properties;
1418
    duration:   number;
1419
    ease:       Ease;
1420
    delay?:     number;
1421
}
1422

1423
export enum Ease {
1424
    Linear = "Linear",
1425
    Quad = "Quad",
1426
    QuadEaseOut = "Quad.easeOut",
1427
}
1428

1429
export interface Properties {
1430
    alpha?:  number;
1431
    x?:      number;
1432
    y?:      number;
1433
    scaleX?: number;
1434
    scaleY?: number;
1435
}
1436

1437
export enum ParametersType {
1438
    GameCompleteV3 = "game_complete_v3",
1439
}
1440

1441
export interface Variables {
1442
    game?:                      Game;
1443
    monster?:                   string;
1444
    gnome?:                     string;
1445
    path?:                      Path;
1446
    x?:                         number;
1447
    shadowWyrmContainer?:       string;
1448
    shadowWyrmSpine?:           string;
1449
    emergeAnimation?:           string;
1450
    shadowWyrmBoss?:            string;
1451
    playerLocomotion?:          string;
1452
    circleTrigger?:             string;
1453
    monsterTransform?:          string;
1454
    chatBubble?:                string;
1455
    monsterWalkAnimator?:       string;
1456
    monsterWalkPosition?:       string;
1457
    monsterSpine?:              string;
1458
    sparklesGameObject?:        string;
1459
    supply?:                    string;
1460
    playerAnimationController?: string;
1461
    supplyTransform?:           string;
1462
    supplyStartingPosition?:    string;
1463
    supplyPosition?:            string;
1464
    rotateSupply?:              boolean;
1465
    morphExpiration?:           string;
1466
}
1467

1468
export interface Results {
1469
    isVictory?:         string;
1470
    newRockPositions?:  string;
1471
    dialogueSelection?: string;
1472
    answerCorrect?:     string;
1473
    skillData?:         string;
1474
    responseTime?:      string;
1475
    instance?:          string;
1476
    component?:         string;
1477
}
1478

1479
export interface Transition {
1480
    state:       string;
1481
    conditions?: Condition[];
1482
}
1483

1484
export interface Condition {
1485
    value:     string;
1486
    lessThan?: number | string;
1487
    equals?:   string;
1488
    type?:     ConditionType;
1489
    test?:     boolean | number | null | string;
1490
}
1491

1492
export enum ConditionType {
1493
    Equals = "equals",
1494
    GreaterThan = "greaterThan",
1495
    NotEquals = "notEquals",
1496
}
1497

1498
export enum FSMType {
1499
    FSM = "fsm",
1500
}
1501

1502
export interface GameFeed {
1503
    ID:       number;
1504
    assetID:  number;
1505
    type:     GameFeedType;
1506
    gender:   number;
1507
    data:     GameFeedData;
1508
    metadata: GameFeedMetadata;
1509
    name:     string;
1510
}
1511

1512
export interface GameFeedData {
1513
    key:          string;
1514
    category:     string;
1515
    notification: Notification;
1516
    modal:        Modal;
1517
    feedText:     string;
1518
    icon:         string;
1519
    autoShare:    boolean;
1520
    eventAction:  EventAction;
1521
    metaData?:    MetaData;
1522
}
1523

1524
export enum EventAction {
1525
    Empty = "",
1526
    MemberAd = "memberAd",
1527
    Teleport = "teleport",
1528
}
1529

1530
export interface MetaData {
1531
    equals?: MetaDataEquals;
1532
}
1533

1534
export interface MetaDataEquals {
1535
    type: TypeElement[];
1536
}
1537

1538
export interface Modal {
1539
    title:  Title;
1540
    body:   string;
1541
    action: ActionEnum;
1542
}
1543

1544
export enum ActionEnum {
1545
    CheckOutLamplightTown = "Check out Lamplight Town",
1546
    CheckOutZoneName = "Check out ${zoneName}",
1547
    Empty = "",
1548
}
1549

1550
export enum Title {
1551
    Empty = "",
1552
    YourFriendBoughtANewItem = "Your friend bought a new item!",
1553
    YourFriendWonANewItem = "Your friend won a new item!",
1554
}
1555

1556
export interface Notification {
1557
    self:   string;
1558
    friend: string;
1559
}
1560

1561
export interface GameFeedMetadata {
1562
    equals?: MetadataEquals;
1563
}
1564

1565
export interface MetadataEquals {
1566
    storeID: number[];
1567
    type:    TypeElement[];
1568
}
1569

1570
export enum GameFeedType {
1571
    GameFeed = "gameFeed",
1572
}
1573

1574
export interface Gender {
1575
    ID:       number;
1576
    assetID:  number;
1577
    type:     string;
1578
    gender:   number;
1579
    data:     GenderData;
1580
    metadata: PurpleMetadata;
1581
    name:     string;
1582
}
1583

1584
export interface GenderData {
1585
    member:     number;
1586
    name:       string;
1587
    saveDataID: string;
1588
    price:      number;
1589
    cost:       CostElement[];
1590
    flavorText: string;
1591
}
1592

1593
export interface Generic {
1594
    ID:       number;
1595
    assetID:  number;
1596
    type:     GenericType;
1597
    gender:   number;
1598
    data:     GenericData;
1599
    metadata: MemberClass;
1600
    name:     string;
1601
}
1602

1603
export interface GenericData {
1604
    name:                          string;
1605
    sections?:                     Sections;
1606
    groups?:                       Groups;
1607
    bountyPetIDs?:                 number[];
1608
    bountyDurationSeconds?:        number;
1609
    totalBounties?:                number;
1610
    totalMemberBounties?:          number;
1611
    tiers?:                        { [key: string]: Tier };
1612
    monsterPoolPetIDs?:            number[];
1613
    bountyElementAlignmentChance?: number;
1614
    unitLevel?:                    UnitLevel;
1615
    teams?:                        Teams;
1616
    spellTierCount?:               number;
1617
    maxEnergy?:                    number;
1618
    elementalAdvantages?:          ElementalAdvantages;
1619
    elementalDisadvantages?:       ElementalAdvantages;
1620
    allOutAttackDamage?:           { [key: string]: { [key: string]: number } };
1621
    allOutAttackBossDamage?:       { [key: string]: { [key: string]: number } };
1622
    minPlayerHeartsOnEndBattle?:   number;
1623
    difficultySwitchChances?:      number[];
1624
    singleShot?:                   Aoe[];
1625
    aoe?:                          Aoe[];
1626
    maxTier?:                      number;
1627
    guardianMaps?:                 { [key: string]: GuardianMap };
1628
    dialogueIDs?:                  number[];
1629
    spellMissCoolDown?:            number;
1630
    restrictedBattleActions?:      string[];
1631
    opponentBackpacks?:            OpponentBackpack[];
1632
    itemMaxCount?:                 ItemMaxCount;
1633
}
1634

1635
export interface Aoe {
1636
    level:   number;
1637
    spellID: number;
1638
}
1639

1640
export interface ElementalAdvantages {
1641
    fire:    EarthElement[];
1642
    water:   EarthElement[];
1643
    earth:   EarthElement[];
1644
    plant:   EarthElement[];
1645
    storm:   EarthElement[];
1646
    mech:    EarthElement[];
1647
    ice:     EarthElement[];
1648
    shadow:  EarthElement[];
1649
    wizard?: AstralElement[];
1650
    astral?: AstralElement[];
1651
}
1652

1653
export interface Groups {
1654
    start:  number[];
1655
    middle: number[];
1656
    end:    number[];
1657
}
1658

1659
export interface GuardianMap {
1660
    zoneName:      string;
1661
    scenePrefabID: number;
1662
    noOrbAlign?:   boolean;
1663
}
1664

1665
export interface ItemMaxCount {
1666
    follow:  number;
1667
    hat:     number;
1668
    outfit:  number;
1669
    boots:   number;
1670
    weapon:  number;
1671
    item:    number;
1672
    orb:     number;
1673
    dorm:    number;
1674
    default: number;
1675
}
1676

1677
export interface OpponentBackpack {
1678
    level:       number;
1679
    itemTableID: number;
1680
}
1681

1682
export interface Sections {
1683
    start:    EasyPath;
1684
    easyPath: EasyPath;
1685
    hardPath: EasyPath;
1686
    end:      EasyPath;
1687
}
1688

1689
export interface EasyPath {
1690
    mapPoolName:          string;
1691
    roomCount:            number;
1692
    objects:              Objects;
1693
    maxEncountersPerRoom: number;
1694
}
1695

1696
export interface Objects {
1697
    easyEncounter:   number;
1698
    mediumEncounter: number;
1699
    hardEncounter:   number;
1700
    goalEncounter:   number;
1701
    basicChest:      number;
1702
    memberChest:     number;
1703
    interactable:    number;
1704
}
1705

1706
export interface Teams {
1707
    limit: UnitLevel;
1708
    units: UnitLevel;
1709
}
1710

1711
export interface Tier {
1712
    member?:                    MemberClass;
1713
    nonMember?:                 NonMember;
1714
    easy?:                      Easy;
1715
    medium?:                    Easy;
1716
    hard?:                      Easy;
1717
    guardianId?:                number;
1718
    guardianMapKey?:            number;
1719
    interactables?:             Interactables;
1720
    lootTables?:                number[];
1721
    baseStatsIncreaseAffixIDs?: number[];
1722
    missCooldown?:              number;
1723
}
1724

1725
export interface Easy {
1726
    teamSize:         UnitLevel;
1727
    possibleAffixIDs: number[];
1728
    lootTables:       number[];
1729
}
1730

1731
export interface Interactables {
1732
    itemTableID: number;
1733
}
1734

1735
export interface NonMember {
1736
    possibleAffixIDs:           number[];
1737
    loot:                       Loot[];
1738
    randomLootTableIDs:         number[];
1739
    baseStatsIncreaseAffixIDs?: number[];
1740
}
1741

1742
export interface Loot {
1743
    itemTableID: number;
1744
    dropCount:   number;
1745
}
1746

1747
export enum GenericType {
1748
    Generic = "generic",
1749
}
1750

1751
export interface GiftBox {
1752
    ID:       number;
1753
    assetID:  number;
1754
    type:     TypeElement;
1755
    gender:   number;
1756
    data:     GiftBoxData;
1757
    metadata: BundleMetadata;
1758
    name:     string;
1759
}
1760

1761
export interface GiftBoxData {
1762
    name:           string;
1763
    isPurchaseable: boolean;
1764
    questions:      number;
1765
    items:          any[];
1766
}
1767

1768
export interface HairElement {
1769
    ID:       number;
1770
    assetID:  number;
1771
    type:     HairType;
1772
    gender:   number;
1773
    data:     EyeColorData;
1774
    metadata: HairMetadata;
1775
    name:     string;
1776
}
1777

1778
export interface HairMetadata {
1779
    x:        number;
1780
    y:        number;
1781
    pivot:    BeijingPigeon;
1782
    vIcon:    number;
1783
    type:     PurpleType;
1784
    v:        number;
1785
    noCache?: boolean;
1786
}
1787

1788
export enum HairType {
1789
    Hair = "hair",
1790
}
1791

1792
export interface Hat {
1793
    ID:       number;
1794
    assetID:  number;
1795
    type:     TypeElement;
1796
    gender:   number;
1797
    data:     BootData;
1798
    metadata: HatMetadata;
1799
    name:     string;
1800
}
1801

1802
export interface HatMetadata {
1803
    v:              number;
1804
    x:              number;
1805
    y:              number;
1806
    type:           PurpleType;
1807
    pivot:          BeijingPigeon;
1808
    vIcon:          number;
1809
    hairHide:       number[];
1810
    hideReplace:    number | string;
1811
    assetVersions?: Version[];
1812
    iconVersions?:  Version[];
1813
    noCache?:       boolean;
1814
    cacheError?:    boolean;
1815
}
1816

1817
export interface GameDataItem {
1818
    ID:       number;
1819
    assetID:  number;
1820
    type:     TypeElement;
1821
    gender:   number;
1822
    data:     FluffyData;
1823
    metadata: ItemMetadata;
1824
    name:     string;
1825
}
1826

1827
export interface FluffyData {
1828
    name:               string;
1829
    price:              number;
1830
    member:             number;
1831
    rarity:             number;
1832
    flavorText:         string;
1833
    type?:              IndecentType;
1834
    target?:            TargetEnum;
1835
    healAmount?:        number;
1836
    drop?:              number;
1837
    effect?:            EffectClass | null;
1838
    effectDescription?: string;
1839
    affix?:             DataAffix;
1840
    subType?:           string;
1841
    element?:           string;
1842
    potency?:           number;
1843
    cost?:              CostElement[];
1844
    affixID?:           number;
1845
}
1846

1847
export interface DataAffix {
1848
    type:        IndigoType;
1849
    elements?:   EarthElement[];
1850
    amount:      number;
1851
    highPotency: boolean;
1852
}
1853

1854
export enum IndigoType {
1855
    CritChance = "critChance",
1856
    Damage = "damage",
1857
    ElementalResistance = "elementalResistance",
1858
}
1859

1860
export interface EffectClass {
1861
    fx?:        string;
1862
    transform?: Transform;
1863
    ID?:        number;
1864
    time?:      number;
1865
}
1866

1867
export enum Transform {
1868
    Dorm = "dorm",
1869
    Follow = "follow",
1870
    Pet = "pet",
1871
}
1872

1873
export enum TargetEnum {
1874
    Team = "team",
1875
    Unit = "unit",
1876
}
1877

1878
export enum IndecentType {
1879
    Consumable = "consumable",
1880
    Food = "food",
1881
    Potion = "potion",
1882
}
1883

1884
export interface ItemMetadata {
1885
    vIcon:   number;
1886
    icon?:   IconEnum;
1887
    assets?: IndecentAssets;
1888
    v?:      number;
1889
    type?:   PurpleType;
1890
}
1891

1892
export interface IndecentAssets {
1893
    icon?:             IconClass;
1894
    morphedApperance?: AdventureReward;
1895
}
1896

1897
export interface IconClass {
1898
    type:  PurpleType;
1899
    ID:    number;
1900
    frame: string;
1901
}
1902

1903
export enum IconEnum {
1904
    Empty = "",
1905
    Item110 = "item/110",
1906
}
1907

1908
export interface ItemTable {
1909
    ID:       number;
1910
    assetID:  number;
1911
    type:     ItemTableType;
1912
    gender:   number;
1913
    data:     ItemTableData;
1914
    metadata: MemberClass;
1915
    name:     string;
1916
}
1917

1918
export interface ItemTableData {
1919
    items:     Fallback[];
1920
    fallback?: Fallback;
1921
    name:      string;
1922
}
1923

1924
export interface Fallback {
1925
    type:     TypeElement;
1926
    ID?:      number;
1927
    quantity: UnitLevel | number;
1928
    weight?:  number;
1929
}
1930

1931
export enum ItemTableType {
1932
    ItemTable = "itemTable",
1933
}
1934

1935
export interface Key {
1936
    ID:       number;
1937
    assetID:  number;
1938
    type:     KeyType;
1939
    gender:   number;
1940
    data:     KeyData;
1941
    metadata: PurpleMetadata;
1942
    name:     string;
1943
}
1944

1945
export interface KeyData {
1946
    name:       string;
1947
    levels:     number;
1948
    flavorText: string;
1949
    quest?:     number | null;
1950
    price?:     number;
1951
}
1952

1953
export enum KeyType {
1954
    Key = "key",
1955
}
1956

1957
export interface MathTown {
1958
    ID:       number;
1959
    assetID:  number;
1960
    type:     MathTownDecorType;
1961
    gender:   number;
1962
    data:     MathTownDecorData;
1963
    metadata: PurpleMetadata;
1964
    name:     string;
1965
}
1966

1967
export interface MathTownDecorData {
1968
    name:            string;
1969
    tag?:            string;
1970
    description:     string;
1971
    element:         number;
1972
    decorPositions?: BeijingPigeon[];
1973
}
1974

1975
export enum MathTownDecorType {
1976
    MathTownDecor = "mathTownDecor",
1977
    MathTownFrame = "mathTownFrame",
1978
}
1979

1980
export interface MathTownInterior {
1981
    ID:       number;
1982
    assetID:  number;
1983
    type:     MathTownInteriorType;
1984
    gender:   number;
1985
    data:     MathTownInteriorData;
1986
    metadata: PurpleMetadata;
1987
    name:     string;
1988
}
1989

1990
export interface MathTownInteriorData {
1991
    name:           string;
1992
    tag?:           string;
1993
    description:    string;
1994
    element:        number;
1995
    flavorText?:    string;
1996
    occupantLevels: number[];
1997
}
1998

1999
export enum MathTownInteriorType {
2000
    MathTownInterior = "mathTownInterior",
2001
}
2002

2003
export interface Mount {
2004
    ID:       number;
2005
    assetID:  number;
2006
    type:     string;
2007
    gender:   number;
2008
    data:     MountData;
2009
    metadata: MountMetadata;
2010
    name:     string;
2011
}
2012

2013
export interface MountData {
2014
    name:       string;
2015
    flavorText: string;
2016
    member:     number;
2017
    drop?:      number;
2018
    price:      number;
2019
    rarity:     number;
2020
    cost?:      CostElement[];
2021
    effects:    number[];
2022
}
2023

2024
export interface MountMetadata {
2025
    vIcon:  number;
2026
    type:   PurpleType;
2027
    assets: HilariousAssets;
2028
}
2029

2030
export interface HilariousAssets {
2031
    below:     Above;
2032
    above:     Above;
2033
    particles: Particles;
2034
}
2035

2036
export interface Above {
2037
    type: PurpleType;
2038
    v:    number;
2039
    x:    number;
2040
    y?:   number;
2041
}
2042

2043
export interface NameElement {
2044
    ID:       number;
2045
    assetID:  number;
2046
    type:     NameType;
2047
    gender:   number;
2048
    data:     NameData;
2049
    metadata: MemberClass;
2050
    name:     string;
2051
}
2052

2053
export interface NameData {
2054
    name:        string;
2055
    value:       string;
2056
    type:        number;
2057
    deprecated?: boolean;
2058
}
2059

2060
export enum NameType {
2061
    Name = "name",
2062
}
2063

2064
export interface Nickname {
2065
    ID:       number;
2066
    assetID:  number;
2067
    type:     NicknameType;
2068
    gender:   number;
2069
    data:     NicknameData;
2070
    metadata: MemberClass;
2071
    name:     string;
2072
}
2073

2074
export interface NicknameData {
2075
    value: string;
2076
    name?: string;
2077
}
2078

2079
export enum NicknameType {
2080
    Nickname = "nickname",
2081
}
2082

2083
export interface ORB {
2084
    ID:       number;
2085
    assetID:  number;
2086
    type:     TypeElement;
2087
    gender:   number;
2088
    data:     ORBData;
2089
    metadata: BundleMetadata;
2090
    name:     string;
2091
}
2092

2093
export interface ORBData {
2094
    name:       string;
2095
    flavorText: string;
2096
    tier:       number;
2097
    rarity:     number;
2098
    affixIDs:   number[];
2099
}
2100

2101
export interface Outfit {
2102
    ID:       number;
2103
    assetID:  number;
2104
    type:     TypeElement;
2105
    gender:   number;
2106
    data:     OutfitData;
2107
    metadata: PurpleMetadata;
2108
    name:     string;
2109
}
2110

2111
export interface OutfitData {
2112
    drop:         number;
2113
    name:         string;
2114
    price?:       number;
2115
    member:       number;
2116
    rarity:       number;
2117
    effects:      Array<number[] | number | string>;
2118
    flavorText:   string;
2119
    id?:          number;
2120
    asset_id?:    number;
2121
    create_date?: string;
2122
    update_date?: string;
2123
    cost?:        CostElement[];
2124
    "en-us"?:     string;
2125
}
2126

2127
export interface GameDataParticleEffect {
2128
    ID:       number;
2129
    assetID:  number;
2130
    type:     string;
2131
    gender:   number;
2132
    data:     ParticleEffectData;
2133
    metadata: MemberClass;
2134
    name:     string;
2135
}
2136

2137
export interface ParticleEffectData {
2138
    name:     string;
2139
    particle: Particle;
2140
    emitter:  Emitter;
2141
}
2142

2143
export interface Emitter {
2144
    repeat:          number;
2145
    frequency:       UnitLevel | number;
2146
    burstFrequency?: UnitLevel;
2147
}
2148

2149
export interface Particle {
2150
    image:       string;
2151
    frame?:      string;
2152
    lifespan:    UnitLevel | number;
2153
    vy:          UnitLevel;
2154
    vx?:         UnitLevel;
2155
    scale?:      Scale;
2156
    alpha?:      Alpha;
2157
    rotation?:   Rotation;
2158
    animations?: Animations;
2159
}
2160

2161
export interface Alpha {
2162
    value:   number;
2163
    control: BeijingPigeon[];
2164
}
2165

2166
export interface Animations {
2167
    clouds: Clouds;
2168
}
2169

2170
export interface Clouds {
2171
    frames:    string[];
2172
    frameRate: number;
2173
    loop:      boolean;
2174
}
2175

2176
export interface Rotation {
2177
    initial: UnitLevel;
2178
    delta:   UnitLevel;
2179
}
2180

2181
export interface Scale {
2182
    value:   UnitLevel | number;
2183
    control: BeijingPigeon[];
2184
}
2185

2186
export interface Pet {
2187
    ID:       number;
2188
    assetID:  number;
2189
    type:     NameEnum;
2190
    gender:   number;
2191
    data:     PetData;
2192
    metadata: PetMetadata;
2193
    name:     string;
2194
}
2195

2196
export interface PetData {
2197
    life?:             Life;
2198
    ordinal?:          number;
2199
    name:              string;
2200
    curve:             Curve[];
2201
    power?:            Life;
2202
    growth?:           string;
2203
    rarity?:           number;
2204
    element:           EarthElement;
2205
    flavorText:        string;
2206
    effects?:          number[];
2207
    price?:            number;
2208
    statHealth:        number;
2209
    statPower:         number;
2210
    foreignSpellPools: Array<number[]>;
2211
    nativeSpells:      NativeSpell[];
2212
    assetType?:        AssetTypeEnum;
2213
    R?:                number;
2214
    special?:          boolean;
2215
    bench?:            Bench[];
2216
    member?:           number;
2217
    adText?:           string;
2218
    unique?:           boolean;
2219
    unlockFollow?:     number;
2220
    epicSpell?:        number;
2221
    cost?:             CostElement[];
2222
}
2223

2224
export interface Bench {
2225
    weight?: number;
2226
    petID?:  number;
2227
    spell?:  number;
2228
}
2229

2230
export interface Curve {
2231
    a?:        number;
2232
    lvl:       number;
2233
    e?:        number;
2234
    evolveID?: number;
2235
}
2236

2237
export enum Life {
2238
    A = "A-",
2239
    B = "B",
2240
    C = "C",
2241
    LifeA = "A",
2242
    LifeB = "B+",
2243
    LifeC = "C-",
2244
    PurpleA = "A+",
2245
    PurpleB = "B-",
2246
    PurpleC = "C+",
2247
}
2248

2249
export interface NativeSpell {
2250
    spell: number;
2251
}
2252

2253
export interface PetMetadata {
2254
    v?:                number;
2255
    type:              PurpleType;
2256
    vIcon:             number;
2257
    assets:            AmbitiousAssets;
2258
    uiConfig?:         UIConfig;
2259
    rewardsExclusive?: boolean;
2260
}
2261

2262
export interface AmbitiousAssets {
2263
    small?:   Above;
2264
    default?: StickyDefault;
2265
    reduced?: Reduced;
2266
    spine?:   AssetsSpine;
2267
}
2268

2269
export interface StickyDefault {
2270
    h?:          number;
2271
    v?:          number;
2272
    w?:          number;
2273
    x?:          number;
2274
    type:        AssetTypeEnum;
2275
    pivotX?:     number;
2276
    battleScale: number;
2277
    ID?:         number;
2278
    hitbox?:     DefaultHitbox;
2279
    flip?:       boolean;
2280
}
2281

2282
export interface Reduced {
2283
    h:       number;
2284
    v:       number;
2285
    w:       number;
2286
    x:       number;
2287
    type:    AssetTypeEnum;
2288
    pivotX?: number;
2289
    hitbox?: DefaultHitbox;
2290
}
2291

2292
export interface AssetsSpine {
2293
    type:        AssetTypeEnum;
2294
    ID:          number;
2295
    battleScale: number;
2296
}
2297

2298
export interface UIConfig {
2299
    type:      ElementType;
2300
    name:      NameEnum;
2301
    anchorX:   number;
2302
    anchorY:   number;
2303
    relativeX: number;
2304
    relativeY: number;
2305
    spineKey:  string;
2306
    animation: string;
2307
    loop:      boolean;
2308
}
2309

2310
export enum ElementType {
2311
    Button = "Button",
2312
    ButtonToggle = "ButtonToggle",
2313
    Graphic = "Graphic",
2314
    InputFieldElement = "InputFieldElement",
2315
    Mask = "Mask",
2316
    PhaserButtonWrapper = "PhaserButtonWrapper",
2317
    ScrollBar = "ScrollBar",
2318
    ScrollView = "ScrollView",
2319
    SlicedBanner = "SlicedBanner",
2320
    SlicedGraphic = "SlicedGraphic",
2321
    Slider = "Slider",
2322
    SpineUI = "SpineUI",
2323
    Tab = "Tab",
2324
    TabButton = "TabButton",
2325
    Text = "Text",
2326
    UIElement = "UIElement",
2327
    VideoGraphic = "VideoGraphic",
2328
    WebFontText = "WebFontText",
2329
    WoodSlicedPanel = "WoodSlicedPanel",
2330
}
2331

2332
export interface PrizeWheel {
2333
    ID:       number;
2334
    assetID:  number;
2335
    type:     string;
2336
    gender:   number;
2337
    data:     PrizeWheelData;
2338
    metadata: null;
2339
    name:     string;
2340
}
2341

2342
export interface PrizeWheelData {
2343
    slots:                     Slot[];
2344
    itemPools:                 Array<CostElement[]>;
2345
    atlas:                     string;
2346
    wheelSprite:               string;
2347
    wheelTop:                  string;
2348
    wheelTopOffset:            BeijingPigeon;
2349
    wheelPointer:              string;
2350
    wheelPointerOffset?:       BeijingPigeon;
2351
    itemDistanceScale?:        number;
2352
    askSpinDialogue?:          string;
2353
    spinningDialogue?:         string;
2354
    outOfSpinsDialogue?:       string;
2355
    spinAgainDialogue?:        string;
2356
    ticketDialogue?:           string;
2357
    eventType:                 string;
2358
    name?:                     string;
2359
    maxedItemPrizeSubstitute?: number;
2360
    firstSpinDialogueID?:      number;
2361
    spinDialogueID?:           number;
2362
    declineSpinDialogueID?:    number;
2363
    spinningDialogueID?:       number;
2364
    prizeReceivedDialogueID?:  number;
2365
    outOfSpinsDialogueID?:     number;
2366
    spinAgainDialogueID?:      number;
2367
    firstSpinBreadcrumb?:      FirstSpinBreadcrumb;
2368
}
2369

2370
export interface FirstSpinBreadcrumb {
2371
    featureName:    string;
2372
    breadcrumbName: string;
2373
}
2374

2375
export interface Slot {
2376
    itemPools: ItemPool[];
2377
    weight:    number;
2378
}
2379

2380
export interface ItemPool {
2381
    index:  number;
2382
    weight: number;
2383
}
2384

2385
export interface Relic {
2386
    ID:       number;
2387
    assetID:  number;
2388
    type:     RelicType;
2389
    gender:   number;
2390
    data:     MountData;
2391
    metadata: BundleMetadata;
2392
    name:     string;
2393
}
2394

2395
export enum RelicType {
2396
    Relic = "relic",
2397
}
2398

2399
export interface Sfx {
2400
    ID:       number;
2401
    assetID:  number;
2402
    type:     SfxType;
2403
    gender:   number;
2404
    data:     SfxData;
2405
    metadata: AtlasMetadata;
2406
    name:     string;
2407
}
2408

2409
export interface SfxData {
2410
    filename: string;
2411
    clips?:   { [key: string]: Clip };
2412
    name?:    string;
2413
}
2414

2415
export interface Clip {
2416
    d: number;
2417
    s: number;
2418
}
2419

2420
export enum SfxType {
2421
    Sfx = "sfx",
2422
}
2423

2424
export interface SingleImage {
2425
    ID:       number;
2426
    assetID:  number;
2427
    type:     PurpleType;
2428
    gender:   number;
2429
    data:     SingleImageData;
2430
    metadata: SingleImageMetadata;
2431
    name:     string;
2432
}
2433

2434
export interface SingleImageData {
2435
    filename?: string;
2436
    name?:     string;
2437
    "en-us"?:  string;
2438
}
2439

2440
export interface SingleImageMetadata {
2441
    assets:     FluffyAssets;
2442
    iconAtlas?: number | string;
2443
    v?:         number;
2444
    petID?:     number;
2445
}
2446

2447
export interface Spell {
2448
    ID:       number;
2449
    assetID:  number;
2450
    type:     SpellType;
2451
    gender:   number;
2452
    data:     SpellData;
2453
    metadata: SpellMetadata;
2454
    name:     string;
2455
}
2456

2457
export interface SpellData {
2458
    name:           string;
2459
    price:          number;
2460
    damage:         number;
2461
    element:        EarthElement;
2462
    animation:      string;
2463
    heal?:          boolean;
2464
    type?:          SpellType | null;
2465
    epicId?:        number | null;
2466
    baseAttack?:    number | string;
2467
    statusEffects?: number[];
2468
    cost?:          CostElement[];
2469
    energyCost?:    number;
2470
    tier?:          number;
2471
    targetType?:    TargetType;
2472
    nextTierID?:    number;
2473
    damageType?:    Type;
2474
}
2475

2476
export enum Type {
2477
    Aoa = "aoa",
2478
    Aoe = "aoe",
2479
    Beam = "beam",
2480
    Projectile = "projectile",
2481
}
2482

2483
export enum TargetType {
2484
    Aoe = "aoe",
2485
    Single = "single",
2486
}
2487

2488
export enum SpellType {
2489
    EpicAttack = "epic-attack",
2490
    Spell = "spell",
2491
}
2492

2493
export interface SpellMetadata {
2494
    vIcon:          number;
2495
    v?:             number;
2496
    type?:          PurpleType;
2497
    assets?:        string[];
2498
    animationData?: AnimationData;
2499
}
2500

2501
export interface AnimationData {
2502
    animationType:         Type;
2503
    createLocation:        CreateLocation;
2504
    impactLocation:        ImpactLocation;
2505
    createRotates:         boolean;
2506
    createBeamDelay:       number | string;
2507
    travelRotates:         boolean;
2508
    travelEasing:          TravelEasing;
2509
    travelDuration:        number;
2510
    sustainDuration:       number;
2511
    endDuration:           number;
2512
    endEasing:             EndEasing;
2513
    impactRotates:         boolean;
2514
    impact2Delay:          number;
2515
    screenDim:             boolean;
2516
    charFromAnimation:     CharFromAnimation;
2517
    charToAnimation:       CharToAnimation;
2518
    charToAnimationDelay:  number | null;
2519
    charToAnimationLength: number | null;
2520
    travelStraight:        boolean;
2521
    impact2Offset?:        Impact2Offset;
2522
    fullTeamAttack?:       boolean;
2523
    castingAnimation?:     CastingAnimation;
2524
    endingMask?:           boolean;
2525
}
2526

2527
export interface CastingAnimation {
2528
    type:      AssetTypeEnum;
2529
    ID:        number;
2530
    offset:    BeijingPigeon;
2531
    animation: string;
2532
}
2533

2534
export enum CharFromAnimation {
2535
    None = "none",
2536
    Vibrate = "vibrate",
2537
}
2538

2539
export enum CharToAnimation {
2540
    Damage = "damage",
2541
    None = "none",
2542
}
2543

2544
export interface CreateLocation {
2545
    createOffsetX: number | null;
2546
    createOffsetY: number;
2547
    createy?:      number;
2548
    createx?:      number;
2549
}
2550

2551
export enum EndEasing {
2552
    ElasticIn = "Elastic.In",
2553
    LinearNone = "Linear.None",
2554
}
2555

2556
export interface Impact2Offset {
2557
    impact2OffsetX: number;
2558
    impact2OffsetY: number;
2559
}
2560

2561
export interface ImpactLocation {
2562
    impactx:  number | null;
2563
    impacty:  number | null;
2564
    offsety?: number;
2565
    offsetx?: number;
2566
}
2567

2568
export enum TravelEasing {
2569
    LinearNone = "Linear.None",
2570
    QuadraticIn = "Quadratic.In",
2571
}
2572

2573
export interface SpellRelic {
2574
    ID:       number;
2575
    assetID:  number;
2576
    type:     SpellRelicType;
2577
    gender:   number;
2578
    data:     SpellRelicData;
2579
    metadata: PurpleMetadata;
2580
    name:     string;
2581
}
2582

2583
export interface SpellRelicData {
2584
    spellID:    number;
2585
    drop:       number;
2586
    rarity:     number;
2587
    name:       string;
2588
    flavorText: string;
2589
    lockLevel?: number;
2590
    levelLock?: number;
2591
}
2592

2593
export enum SpellRelicType {
2594
    SpellRelic = "spellRelic",
2595
}
2596

2597
export interface SpineElement {
2598
    ID:       number;
2599
    assetID:  number;
2600
    type:     AssetTypeEnum;
2601
    gender:   number;
2602
    data:     AtlasData;
2603
    metadata: SpineMetadata;
2604
    name:     string;
2605
}
2606

2607
export interface SpineMetadata {
2608
    assets: CunningAssets;
2609
    type?:  PurpleType;
2610
}
2611

2612
export interface CunningAssets {
2613
    default: IndigoDefault;
2614
}
2615

2616
export interface IndigoDefault {
2617
    v:       number;
2618
    type?:   AssetTypeEnum;
2619
    hitbox?: DefaultHitbox;
2620
}
2621

2622
export interface Tileset {
2623
    ID:       number;
2624
    assetID:  number;
2625
    type:     string;
2626
    gender:   number;
2627
    data:     TilesetData;
2628
    metadata: MemberClass;
2629
    name:     string;
2630
}
2631

2632
export interface TilesetData {
2633
    data:     TentacledData;
2634
    metadata: AtlasMetadata;
2635
    name:     string;
2636
}
2637

2638
export interface TentacledData {
2639
    name:     string;
2640
    filename: string;
2641
    w:        number;
2642
    h:        number;
2643
}
2644

2645
export interface Titan {
2646
    ID:       number;
2647
    assetID:  number;
2648
    type:     string;
2649
    gender:   number;
2650
    data:     TitanData;
2651
    metadata: SpineMetadata;
2652
    name:     string;
2653
}
2654

2655
export interface TitanData {
2656
    name:       string;
2657
    zone:       string;
2658
    maxHealth:  number;
2659
    element:    EarthElement;
2660
    difficulty: number;
2661
    spellList:  number[];
2662
    rewards:    Reward[];
2663
    spine:      string;
2664
}
2665

2666
export interface Reward {
2667
    rank:        number;
2668
    threshold:   number;
2669
    mailKey:     MailKey;
2670
    attachments: CostElement[];
2671
    mapping:     number[];
2672
}
2673

2674
export enum MailKey {
2675
    TitanReward = "titanReward",
2676
}
2677

2678
export interface UI {
2679
    ID:       number;
2680
    assetID:  number;
2681
    type:     UIType;
2682
    gender:   number;
2683
    data:     UIData;
2684
    metadata: MemberClass;
2685
    name:     string;
2686
}
2687

2688
export interface UIData {
2689
    name?:      string;
2690
    elements?:  FluffyElement[];
2691
    templates?: Template[];
2692
    data?:      StickyData;
2693
    metadata?:  MemberClass;
2694
}
2695

2696
export interface StickyData {
2697
    name:     string;
2698
    elements: PurpleElement[];
2699
}
2700

2701
export interface PurpleElement {
2702
    type:     ElementType;
2703
    name:     string;
2704
    x:        number;
2705
    y:        number;
2706
    width:    number;
2707
    height:   number;
2708
    children: any[];
2709
}
2710

2711
export interface FluffyElement {
2712
    type:                        ElementType;
2713
    name?:                       string;
2714
    anchorX?:                    number;
2715
    anchorY?:                    number;
2716
    relativeX?:                  number;
2717
    relativeY?:                  number;
2718
    width?:                      number;
2719
    relativeHeight?:             number;
2720
    atlasID?:                    number | string;
2721
    baseFrameName?:              string;
2722
    sliceType?:                  SliceType;
2723
    children?:                   ElementChild[];
2724
    relativeWidth?:              number;
2725
    height?:                     number;
2726
    textKey?:                    string;
2727
    frameName?:                  string;
2728
    x?:                          number;
2729
    y?:                          number;
2730
    activeTrackBaseFrameName?:   string;
2731
    inactiveTrackBaseFrameName?: string;
2732
    showHead?:                   boolean;
2733
    isVertical?:                 boolean;
2734
    isInteractive?:              boolean;
2735
    thumbAnchor?:                BeijingPigeon;
2736
    spineKey?:                   string;
2737
    visible?:                    boolean;
2738
    isThreeSlice?:               boolean;
2739
    frameNameOn?:                string;
2740
    frameNameOff?:               string;
2741
    defaultToggleState?:         number;
2742
}
2743

2744
export interface ElementChild {
2745
    type:                        ElementType;
2746
    name?:                       string;
2747
    relativeWidth?:              number;
2748
    relativeHeight?:             number;
2749
    children?:                   PurpleChild[];
2750
    anchorX?:                    number;
2751
    anchorY?:                    number;
2752
    relativeX?:                  number;
2753
    relativeY?:                  number;
2754
    atlasID?:                    number;
2755
    baseFrameName?:              string;
2756
    text?:                       string;
2757
    visible?:                    boolean;
2758
    layoutConfig?:               LayoutConfig;
2759
    textKey?:                    string;
2760
    x?:                          number;
2761
    y?:                          number;
2762
    height?:                     number;
2763
    width?:                      number;
2764
    sliceType?:                  SliceType;
2765
    frameName?:                  string;
2766
    fontID?:                     number;
2767
    fontSize?:                   number;
2768
    upStateName?:                string;
2769
    downStateName?:              string;
2770
    buttonTextName?:             string;
2771
    hoverLiftDistance?:          number;
2772
    atlasName?:                  AtlasName;
2773
    wordWrap?:                   boolean;
2774
    style?:                      number;
2775
    color?:                      string;
2776
    align?:                      BoundsAlignH;
2777
    boundsAlignH?:               BoundsAlignH;
2778
    boundsAlignV?:               BoundsAlignH;
2779
    toggle?:                     boolean;
2780
    textOffset?:                 number;
2781
    forceUpperCase?:             boolean;
2782
    activeTrackBaseFrameName?:   string;
2783
    inactiveTrackBaseFrameName?: string;
2784
    thumbFrameName?:             string;
2785
    showHead?:                   boolean;
2786
    isVertical?:                 boolean;
2787
    isInteractive?:              boolean;
2788
    thumbAnchor?:                BeijingPigeon;
2789
    scaleX?:                     number;
2790
    lineSpacing?:                number;
2791
    singleImageID?:              number;
2792
    tint?:                       number;
2793
    overStateName?:              FluffyOverStateName;
2794
}
2795

2796
export enum BoundsAlignH {
2797
    Bottom = "bottom",
2798
    Center = "center",
2799
    Left = "left",
2800
    Middle = "middle",
2801
    Right = "right",
2802
    Top = "top",
2803
}
2804

2805
export enum AtlasName {
2806
    Empty = "",
2807
    UIShared = "ui-shared",
2808
}
2809

2810
export interface PurpleChild {
2811
    type:                 ElementType;
2812
    name?:                string;
2813
    anchorX?:             number;
2814
    anchorY?:             number;
2815
    relativeX?:           number;
2816
    relativeY?:           number;
2817
    relativeHeight?:      number;
2818
    relativeWidth?:       number;
2819
    visible?:             boolean;
2820
    children?:            FluffyChild[];
2821
    atlasID?:             number;
2822
    baseFrameName?:       string;
2823
    sliceType?:           SliceType;
2824
    width?:               number;
2825
    height?:              number;
2826
    textKey?:             string;
2827
    fontID?:              number;
2828
    fontSize?:            number;
2829
    horizontalAlignment?: BoundsAlignH;
2830
    verticalAlignment?:   BoundsAlignH;
2831
    text?:                string;
2832
    layoutConfig?:        LayoutConfig;
2833
    x?:                   number;
2834
    frameName?:           string;
2835
    tabID?:               number;
2836
    isThreeSlice?:        boolean;
2837
    upStateName?:         string;
2838
    downStateName?:       string;
2839
    buttonTextName?:      string;
2840
    hoverLiftDistance?:   number;
2841
    y?:                   number;
2842
    horizontalFlip?:      boolean;
2843
    atlasName?:           string;
2844
    thumbFrameName?:      string;
2845
    trackFrameName?:      string;
2846
    color?:               string;
2847
    style?:               number;
2848
    boundsAlignH?:        BoundsAlignH;
2849
    boundsAlignV?:        BoundsAlignH;
2850
    spineKey?:            string;
2851
    wordWrap?:            boolean;
2852
    textOffset?:          number;
2853
    align?:               BoundsAlignH;
2854
    groupID?:             number;
2855
    lineSpacing?:         number;
2856
    forceUpperCase?:      boolean;
2857
    isVertical?:          boolean;
2858
    rotateSprites?:       boolean;
2859
    anxhorY?:             number;
2860
    toggle?:              boolean;
2861
    scaleX?:              number;
2862
    overStateName?:       PurpleOverStateName;
2863
    singleImageID?:       number;
2864
    scaleY?:              number;
2865
    wordWrapWidth?:       number;
2866
}
2867

2868
export interface FluffyChild {
2869
    type:                        ElementType;
2870
    name?:                       string;
2871
    anchorX?:                    number;
2872
    anchorY?:                    number;
2873
    relativeX?:                  number;
2874
    relativeY?:                  number;
2875
    atlasID?:                    number;
2876
    frameName?:                  string;
2877
    relativeWidth?:              number;
2878
    relativeHeight?:             number;
2879
    children?:                   TentacledChild[];
2880
    baseFrameName?:              string;
2881
    sliceType?:                  SliceType;
2882
    height?:                     number;
2883
    textKey?:                    string;
2884
    fontID?:                     number;
2885
    fontSize?:                   number;
2886
    horizontalAlignment?:        BoundsAlignH;
2887
    forceUpperCase?:             boolean;
2888
    width?:                      number;
2889
    visible?:                    boolean;
2890
    text?:                       string;
2891
    verticalAlignment?:          BoundsAlignH;
2892
    y?:                          number;
2893
    x?:                          number;
2894
    thumbFrameName?:             string;
2895
    activeTrackBaseFrameName?:   string;
2896
    inactiveTrackBaseFrameName?: string;
2897
    isVertical?:                 boolean;
2898
    atlasName?:                  AtlasName;
2899
    layoutConfig?:               LayoutConfig;
2900
    boundsAlignH?:               BoundsAlignH;
2901
    boundsAlignV?:               BoundsAlignH;
2902
    style?:                      number;
2903
    color?:                      string;
2904
    wordWrap?:                   boolean;
2905
    scrollContentsName?:         string;
2906
    enableTouchScroll?:          boolean;
2907
    trackFrameName?:             string;
2908
    upStateName?:                string;
2909
    downStateName?:              string;
2910
    buttonTextName?:             string;
2911
    hoverLiftDistance?:          number;
2912
    toggle?:                     boolean;
2913
    lineSpacing?:                number;
2914
    align?:                      BoundsAlignH;
2915
    rotateSprites?:              boolean;
2916
    scaleX?:                     number;
2917
    showHead?:                   boolean;
2918
    isInteractive?:              boolean;
2919
    thumbAnchor?:                BeijingPigeon;
2920
    spineKey?:                   string;
2921
    singleImageID?:              number;
2922
}
2923

2924
export interface TentacledChild {
2925
    type:                        ElementType;
2926
    name?:                       string;
2927
    relativeHeight?:             number;
2928
    relativeWidth?:              number;
2929
    text?:                       string;
2930
    fontID?:                     number;
2931
    fontSize?:                   number;
2932
    horizontalAlignment?:        BoundsAlignH;
2933
    atlasID?:                    number;
2934
    baseFrameName?:              string;
2935
    sliceType?:                  SliceType;
2936
    height?:                     number;
2937
    textKey?:                    string;
2938
    verticalAlignment?:          BoundsAlignH;
2939
    visible?:                    boolean;
2940
    anchorX?:                    number;
2941
    anchorY?:                    number;
2942
    relativeX?:                  number;
2943
    relativeY?:                  number;
2944
    frameName?:                  string;
2945
    forceUpperCase?:             boolean;
2946
    children?:                   StickyChild[];
2947
    activeTrackBaseFrameName?:   string;
2948
    inactiveTrackBaseFrameName?: string;
2949
    endCapAtlas?:                string;
2950
    endCapFrameName?:            string;
2951
    showHead?:                   boolean;
2952
    isVertical?:                 boolean;
2953
    isInteractive?:              boolean;
2954
    scrollContentsName?:         string;
2955
    enableTouchScroll?:          boolean;
2956
    width?:                      number;
2957
    thumbFrameName?:             string;
2958
    trackFrameName?:             string;
2959
    upStateName?:                string;
2960
    downStateName?:              string;
2961
    buttonTextName?:             string;
2962
    hoverLiftDistance?:          number;
2963
    y?:                          number;
2964
    style?:                      number;
2965
    color?:                      string;
2966
    boundsAlignH?:               BoundsAlignH;
2967
    boundsAlignV?:               BoundsAlignH;
2968
    wordWrap?:                   boolean;
2969
    layoutConfig?:               LayoutConfig;
2970
    x?:                          number;
2971
    atlasName?:                  AtlasName;
2972
    singleImageID?:              number;
2973
    tint?:                       number;
2974
}
2975

2976
export interface StickyChild {
2977
    type:                 ElementType;
2978
    name:                 string;
2979
    anchorX?:             number;
2980
    anchorY?:             number;
2981
    relativeX?:           number;
2982
    relativeY?:           number;
2983
    atlasID?:             number;
2984
    frameName?:           string;
2985
    relativeHeight?:      number;
2986
    relativeWidth?:       number;
2987
    textKey?:             string;
2988
    fontID?:              number;
2989
    fontSize?:            number;
2990
    horizontalAlignment?: BoundsAlignH;
2991
    verticalAlignment?:   BoundsAlignH;
2992
    layoutConfig?:        LayoutConfig;
2993
    baseFrameName?:       string;
2994
    sliceType?:           SliceType;
2995
    height?:              number;
2996
    text?:                string;
2997
    forceUpperCase?:      boolean;
2998
    children?:            IndigoChild[];
2999
    style?:               number;
3000
    wordWrap?:            boolean;
3001
    wordWrapWidth?:       number;
3002
    color?:               PurpleColor;
3003
    lineSpacing?:         number;
3004
    width?:               number;
3005
    boundsAlignH?:        BoundsAlignH;
3006
    boundsAlignV?:        BoundsAlignH;
3007
    atlasName?:           AtlasName;
3008
}
3009

3010
export interface IndigoChild {
3011
    type:                        ElementType;
3012
    name:                        string;
3013
    relativeX:                   number;
3014
    relativeY:                   number;
3015
    anchorX:                     number;
3016
    anchorY:                     number;
3017
    style?:                      number;
3018
    fontSize?:                   number;
3019
    color?:                      string;
3020
    boundsAlignH?:               BoundsAlignH;
3021
    boundsAlignV?:               BoundsAlignH;
3022
    lineSpacing?:                number;
3023
    atlasID?:                    number;
3024
    frameName?:                  string;
3025
    width?:                      number;
3026
    height?:                     number;
3027
    activeTrackBaseFrameName?:   string;
3028
    inactiveTrackBaseFrameName?: string;
3029
    thumbFrameName?:             string;
3030
    showHead?:                   boolean;
3031
    isVertical?:                 boolean;
3032
    isInteractive?:              boolean;
3033
    thumbAnchor?:                BeijingPigeon;
3034
}
3035

3036
export enum PurpleColor {
3037
    C16A2C = "#c16a2c",
3038
    The363636 = "#363636",
3039
    The3687Ba = "#3687ba",
3040
}
3041

3042
export interface LayoutConfig {
3043
    type:             LayoutConfigType;
3044
    alignment:        BoundsAlignH;
3045
    offset?:          number;
3046
    spacing?:         number;
3047
    ignoreInvisible?: boolean;
3048
}
3049

3050
export enum LayoutConfigType {
3051
    Horizontal = "horizontal",
3052
    Vertical = "vertical",
3053
}
3054

3055
export enum SliceType {
3056
    Nine = "nine",
3057
    NineScale = "nineScale",
3058
    Three = "three",
3059
    ThreeScale = "threeScale",
3060
}
3061

3062
export enum PurpleOverStateName {
3063
    WatchNowGraphicOverContainer = "watchNowGraphicOverContainer",
3064
}
3065

3066
export enum FluffyOverStateName {
3067
    GoNowGraphicOver = "goNowGraphicOver",
3068
    WatchVideoGraphicOver = "watchVideoGraphicOver",
3069
}
3070

3071
export interface Template {
3072
    type:               ElementType;
3073
    name:               string;
3074
    anchorX?:           number;
3075
    anchorY?:           number;
3076
    relativeX?:         number;
3077
    relativeY?:         number;
3078
    width?:             number;
3079
    height?:            number;
3080
    atlasID?:           number;
3081
    baseFrameName?:     string;
3082
    sliceType?:         SliceType;
3083
    children?:          TemplateChild[];
3084
    frameName?:         string;
3085
    relativeWidth?:     number;
3086
    relativeHeight?:    number;
3087
    visible?:           boolean;
3088
    x?:                 number;
3089
    y?:                 number;
3090
    layoutConfig?:      LayoutConfig;
3091
    atlasName?:         AtlasName;
3092
    text?:              string;
3093
    style?:             number;
3094
    boundsAlignH?:      BoundsAlignH;
3095
    boundsAlignV?:      BoundsAlignH;
3096
    upStateName?:       string;
3097
    downStateName?:     string;
3098
    buttonTextName?:    string;
3099
    hoverLiftDistance?: number;
3100
    toggle?:            boolean;
3101
}
3102

3103
export interface TemplateChild {
3104
    type:                 ElementType;
3105
    name:                 string;
3106
    relativeWidth?:       number;
3107
    relativeHeight?:      number;
3108
    anchorX?:             number;
3109
    anchorY?:             number;
3110
    relativeX?:           number;
3111
    relativeY?:           number;
3112
    height?:              number;
3113
    text?:                string;
3114
    fontID?:              number;
3115
    fontSize?:            number;
3116
    horizontalAlignment?: BoundsAlignH;
3117
    verticalAlignment?:   BoundsAlignH;
3118
    visible?:             boolean;
3119
    atlasID?:             number;
3120
    baseFrameName?:       string;
3121
    sliceType?:           SliceType;
3122
    children?:            IndecentChild[];
3123
    x?:                   number;
3124
    y?:                   number;
3125
    width?:               number;
3126
    frameName?:           string;
3127
    isThreeSlice?:        boolean;
3128
    textKey?:             string;
3129
    forceUpperCase?:      boolean;
3130
    style?:               number;
3131
    color?:               FluffyColor;
3132
    boundsAlignH?:        BoundsAlignH;
3133
    boundsAlignV?:        BoundsAlignH;
3134
    align?:               BoundsAlignH;
3135
    wordWrap?:            boolean;
3136
    upStateName?:         string;
3137
    downStateName?:       string;
3138
    buttonTextName?:      string;
3139
    hoverLiftDistance?:   number;
3140
    isVertical?:          boolean;
3141
    spineKey?:            string;
3142
    atlasName?:           AtlasName;
3143
    rotateSprites?:       boolean;
3144
    toggle?:              boolean;
3145
}
3146

3147
export interface IndecentChild {
3148
    type:                        ElementType;
3149
    name:                        string;
3150
    anchorY?:                    number;
3151
    relativeX?:                  number;
3152
    relativeY?:                  number;
3153
    atlasID?:                    number;
3154
    frameName?:                  string;
3155
    anchorX?:                    number;
3156
    relativeWidth?:              number;
3157
    relativeHeight?:             number;
3158
    baseFrameName?:              string;
3159
    sliceType?:                  SliceType;
3160
    visible?:                    boolean;
3161
    children?:                   HilariousChild[];
3162
    text?:                       string;
3163
    fontID?:                     number;
3164
    fontSize?:                   number;
3165
    horizontalAlignment?:        BoundsAlignH;
3166
    verticalAlignment?:          BoundsAlignH;
3167
    height?:                     number;
3168
    activeTrackBaseFrameName?:   string;
3169
    inactiveTrackBaseFrameName?: string;
3170
    thumbFrameName?:             string;
3171
    thumbAnchor?:                BeijingPigeon;
3172
    isVertical?:                 boolean;
3173
    isInteractive?:              boolean;
3174
    width?:                      number;
3175
    wordWrap?:                   boolean;
3176
    color?:                      string;
3177
    textKey?:                    string;
3178
    align?:                      BoundsAlignH;
3179
    boundsAlignH?:               BoundsAlignH;
3180
    boundsAlignV?:               BoundsAlignH;
3181
    style?:                      number;
3182
    horizontalFlip?:             boolean;
3183
    forceUpperCase?:             boolean;
3184
    x?:                          number;
3185
    y?:                          number;
3186
    atlasName?:                  AtlasName;
3187
    layoutConfig?:               LayoutConfig;
3188
    showHead?:                   boolean;
3189
    spineKey?:                   string;
3190
    upStateName?:                string;
3191
    downStateName?:              string;
3192
    buttonTextName?:             string;
3193
    hoverLiftDistance?:          number;
3194
    toggle?:                     boolean;
3195
    textOffset?:                 number;
3196
    url?:                        string;
3197
    autoStart?:                  boolean;
3198
    manuallyCreate?:             boolean;
3199
    videoScaleX?:                number;
3200
    videoScaleY?:                number;
3201
}
3202

3203
export interface HilariousChild {
3204
    type:                        ElementType;
3205
    name:                        string;
3206
    relativeHeight?:             number;
3207
    relativeWidth?:              number;
3208
    anchorX?:                    number;
3209
    anchorY?:                    number;
3210
    relativeX?:                  number;
3211
    relativeY?:                  number;
3212
    text?:                       string;
3213
    fontID?:                     number;
3214
    fontSize?:                   number;
3215
    horizontalAlignment?:        BoundsAlignH;
3216
    verticalAlignment?:          BoundsAlignH;
3217
    atlasID?:                    number;
3218
    frameName?:                  string;
3219
    textKey?:                    string;
3220
    forceUpperCase?:             boolean;
3221
    width?:                      number;
3222
    height?:                     number;
3223
    y?:                          number;
3224
    style?:                      number;
3225
    color?:                      FluffyColor;
3226
    boundsAlignH?:               BoundsAlignH;
3227
    boundsAlignV?:               BoundsAlignH;
3228
    wordWrap?:                   boolean;
3229
    x?:                          number;
3230
    align?:                      BoundsAlignH;
3231
    children?:                   AmbitiousChild[];
3232
    offset?:                     number;
3233
    activeTrackBaseFrameName?:   string;
3234
    inactiveTrackBaseFrameName?: string;
3235
    endCapAtlas?:                string;
3236
    endCapFrameName?:            string;
3237
    showHead?:                   boolean;
3238
    isVertical?:                 boolean;
3239
    isInteractive?:              boolean;
3240
    baseFrameName?:              string;
3241
    sliceType?:                  SliceType;
3242
    visible?:                    boolean;
3243
    lineSpacing?:                number;
3244
    atlasName?:                  AtlasName;
3245
    fieldColour?:                string;
3246
    placeholderText?:            string;
3247
    isPassword?:                 boolean;
3248
    hoverLiftDistance?:          number;
3249
}
3250

3251
export interface AmbitiousChild {
3252
    type:            ElementType;
3253
    name:            string;
3254
    textKey?:        string;
3255
    forceUpperCase?: boolean;
3256
    width?:          number;
3257
    height?:         number;
3258
    x?:              number;
3259
    y?:              number;
3260
    anchorX?:        number;
3261
    anchorY?:        number;
3262
    style?:          number;
3263
    fontSize?:       number;
3264
    color?:          string;
3265
    align?:          BoundsAlignH;
3266
    boundsAlignH?:   BoundsAlignH;
3267
    boundsAlignV?:   BoundsAlignH;
3268
    relativeWidth?:  number;
3269
    relativeHeight?: number;
3270
    relativeX?:      number;
3271
    relativeY?:      number;
3272
    atlasID?:        number;
3273
    frameName?:      string;
3274
    visible?:        boolean;
3275
    children?:       CunningChild[];
3276
    text?:           string;
3277
    wordWrap?:       boolean;
3278
    baseFrameName?:  string;
3279
    sliceType?:      SliceType;
3280
}
3281

3282
export interface CunningChild {
3283
    type:            ElementType;
3284
    name:            string;
3285
    text?:           string;
3286
    relativeX:       number;
3287
    relativeY:       number;
3288
    anchorX:         number;
3289
    anchorY:         number;
3290
    wordWrap:        boolean;
3291
    style:           number;
3292
    boundsAlignH:    BoundsAlignH;
3293
    boundsAlignV:    BoundsAlignH;
3294
    textKey?:        string;
3295
    relativeHeight?: number;
3296
    relativeWidth?:  number;
3297
    fontSize?:       number;
3298
    color?:          PurpleColor;
3299
}
3300

3301
export enum FluffyColor {
3302
    Black = "black",
3303
    E83E45 = "#E83E45",
3304
    Ffffff = "#ffffff",
3305
    The000000 = "#000000",
3306
    The363636 = "#363636",
3307
    The372623 = "#372623",
3308
    The865Fb1 = "#865FB1",
3309
}
3310

3311
export enum UIType {
3312
    UI = "ui",
3313
}
3314

3315
export interface Weapon {
3316
    ID:       number;
3317
    assetID:  number;
3318
    type:     TypeElement;
3319
    gender:   number;
3320
    data:     WeaponData;
3321
    metadata: WeaponMetadata;
3322
    name:     string;
3323
}
3324

3325
export interface WeaponData {
3326
    drop:       number;
3327
    name:       string;
3328
    price:      number;
3329
    member:     number;
3330
    rarity:     number;
3331
    effects:    number[];
3332
    flavorText: string;
3333
    spellID?:   number;
3334
    lockLevel?: number;
3335
    memberAd?:  number;
3336
    cost?:      CostElement[];
3337
    "en-us"?:   string;
3338
}
3339

3340
export interface WeaponMetadata {
3341
    v:                 number;
3342
    size:              number;
3343
    type:              PurpleType;
3344
    angle:             number;
3345
    vIcon:             number;
3346
    anchor:            BeijingPigeon;
3347
    x?:                number;
3348
    y?:                number;
3349
    "anchor "?:        BeijingPigeon;
3350
    assetVersions?:    Version[];
3351
    iconVersions?:     Version[];
3352
    noCache?:          boolean;
3353
    rewardsExclusive?: boolean;
3354
}
3355

3356
export declare type GameItemKey =
3357
	| "ad"
3358
	| "affix"
3359
	| "atlas"
3360
	| "bgm"
3361
	| "bitmapFont"
3362
	| "boots"
3363
	| "boss"
3364
	| "bundle"
3365
	| "currency"
3366
	| "dailyReward"
3367
	| "dialogue"
3368
	| "dorm"
3369
	| "dormbg"
3370
	| "dungeon"
3371
	| "emote"
3372
	| "eyeColor"
3373
	| "face"
3374
	| "faceColor"
3375
	| "follow"
3376
	| "fontStyle"
3377
	| "fossil"
3378
	| "fsm"
3379
	| "gameFeed"
3380
	| "gender"
3381
	| "giftBox"
3382
	| "hair"
3383
	| "hairColor"
3384
	| "hat"
3385
	| "item"
3386
	| "key"
3387
	| "mathTownDecor"
3388
	| "mathTownFrame"
3389
	| "mathTownInterior"
3390
	| "mount"
3391
	| "name"
3392
	| "nickname"
3393
	| "outfit"
3394
	| "particleEffect"
3395
	| "pet"
3396
	| "prefab"
3397
	| "prizeWheel"
3398
	| "relic"
3399
	| "sfx"
3400
	| "singleImage"
3401
	| "skinColor"
3402
	| "spell"
3403
	| "spellRelic"
3404
	| "spine"
3405
	| "titan"
3406
	| "ui"
3407
	| "weapon"
3408
	| "featureRequirement";
3409

3410