lol-constants 2.26.0 → 3.0.0-rc.1

package/README.md

@@ -1,28 +1,130 @@
-Provides constants and types for League of Legends related stuff within the context of [Riot APIs](https://developer.riotgames.com/docs/lol). Types such as [`ChampionId`](src/core/constants/Champions/ChampionIds.ts), [`ChampionName`](src/core/constants/Champions/ChampionNames.ts), [`ItemKey`](src/core/constants/Items/ItemKeys.ts), [`RuneId`](src/core/constants/Runes/RuneSetsByRuneNames.ts#L55), [`SpellName`](src/core/constants/Spells/SpellNames.ts), [`Position`](src/core/constants/Positions.ts), [`QueueType`](src/core/constants/QueueTypes.ts), [`RankedTier`](src/core/constants/RankedTiers.ts), [`Region`](src/core/constants/Regions.ts) and more are provided. Certain URLs and URIs are available as constants as well: [`DataDragonUrls`](src/core/constants/DataDragonUrls.ts), [`PlatformApiUris`](src/core/constants/PlatformApiUris.ts), [`RegionalApiUris`](src/core/constants/RegionalApiUris.ts).
-
-Advantages:
-- Types
-- Four categories — champions, items, runes, summoner spells — are armed with getter functions that exchange between id–key–name such as [`getChampionNameByKey`](src/core/helpers/Champions/getChampionNameByKey.ts)–[`getChampionIdByName`](src/core/helpers/Champions/getChampionIdByName.ts)–[`getChampionKeyById`](src/core/helpers/Champions/getChampionKeyById.ts)
-- Types can be validated through type-validating functions such as [`isChampionName`](src/core/helpers/Champions/isChampionName.ts)
-- Type validation functions such as [`isChampionName`](src/core/helpers/Champions/isChampionName.ts) and getter functions such as [`getChampionNameByKey`](src/core/helpers/Champions/getChampionNameByKey.ts) are instantaneous $O(1)$ and do not iterate over many elements
-
-# Champions
-| constants | types | getters | type-validators
-| --- | --- | --- | --- |
-`ChampionIds`, `ChampionIdsByName`, `ChampionKeys`, `ChampionKeysNum`, `ChampionNames` | `ChampionId`, `ChampionKey`, `ChampionKeyNum`, `ChampionName` | `getChampionIdByKey`, `getChampionIdByName`, `getChampionKeyById`, `getChampionKeyByName`, `getChampionNameById`, `getChampionNameByKey` | `isChampionId`, `isChampionKey`, `isChampionKeyNum`, `isChampionName`
-# Items
-| constants | types | getters | type-validators
-| --- | --- | --- | --- |
-`BootsItemKeys`, `BootsItemKeysNum`, `BootsItemNames`, `ItemKeys`, `ItemKeysNum`, `ItemNames`, `ItemTypes`, `LegendaryItemKeys`, `LegendaryItemKeysNum`, `LegendaryItemNames` | `BootsItemKey`, `BootsItemKeyNum`, `BootsItemName`, `ItemKey`, `ItemKeyNum`, `ItemName`, `ItemType`, `LegendaryItemKey`, `LegendaryItemKeyNum`, `LegendaryItemName` | `getItemKeyByName`, `getItemNameByKey` | `isBootsItemKey`, `isBootsItemKeyNum`, `isBootsItemName`, `isItemKey`, `isItemKeyNum`, `isItemName`, `isItemType`, `isLegendaryItemKey`, `isLegendaryItemKeyNum`, `isLegendaryItemName`
-# Runes
-| constants | types | getters | type-validators
-| --- | --- | --- | --- |
-`KeystoneIds`, `KeystoneIdsNum`, `KeystoneNames`, `NonStatRuneIds`, `NonStatRuneIdsNum`, `NonStatRuneNames`, `PrimaryRuneTrees`, `PrimaryRuneTreesByRuneNames`, `PrimaryRuneTreesByRuneNamesNum`, `RuneHSets`, `RuneHSetsByRuneNames`, `RuneHSetsByRuneNamesNum`, `RuneIconFileNames`, `RuneIds`, `RuneIdsNum`, `RuneNames`, `RunePickingRelationships`, `RuneSets`, `RuneSetsByRuneNames`, `RuneSetsByRuneNamesNum`, `RuneTreeIds`, `RuneTreeIdsNum`, `RuneTreeNames`, `RuneTreeTypes`, `SecondaryRuneTrees`, `SecondaryRuneTreesByRuneNames`, `SecondaryRuneTreesByRuneNamesNum`, `StatRuneHSets`, `StatRuneHSetsByRuneNames`, `StatRuneHSetsByRuneNamesNum`, `StatRuneIds`, `StatRuneIdsNum`, `StatRuneNames` | `NonStatRuneId`, `NonStatRuneIdNum`, `NonStatRuneName`, `RuneIconFile`, `RuneId`, `RuneIdNum`, `RuneName`, `RuneTreeId`, `RuneTreeIdNum`, `RuneTreeName`, `RuneTreeType`, `StatRuneId`, `StatRuneIdNum`, `StatRuneName` | `getNonStatRuneIdByName`, `getNonStatRuneNameById`, `getRuneCategoryName`, `getRuneCdnUrl`, `getRuneIdByName`, `getRuneNameById`, `getRuneTreeIdByName`, `getRuneTreeIdNumByName`, `getRuneTreeNameById`, `getStatRuneIdByName`, `getStatRuneNameById` | `isDominationRuneId`, `isDominationRuneIdNum`, `isDominationRuneName`, `isInspirationRuneId`, `isInspirationRuneIdNum`, `isInspirationRuneName`, `isKeystoneRuneId`, `isKeystoneRuneIdNum`, `isKeystoneRuneName`, `isNonStatRuneId`, `isNonStatRuneIdNum`, `isNonStatRuneName`, `isPrecisionRuneId`, `isPrecisionRuneIdNum`, `isPrecisionRuneName`, `isResolveRuneId`, `isResolveRuneIdNum`, `isResolveRuneName`, `isRuneId`, `isRuneIdNum`, `isRuneName`, `isRuneTreeId`, `isRuneTreeIdNum`, `isRuneTreeName`, `isRuneTreeType`, `isSorceryRuneId`, `isSorceryRuneIdNum`, `isSorceryRuneName`, `isStatRuneId`, `isStatRuneIdNum`, `isStatRuneName`
-# Summoner spells
-| constants | types | getters | type-validators
-| --- | --- | --- | --- |
-`SpellIds`, `SpellIdsByName`, `SpellKeys`, `SpellKeysNum`, `SpellNames` | `SpellId`, `SpellKey`, `SpellKeyNum`, `SpellName` | `getSpellIdByKey`, `getSpellIdByName`, `getSpellKeyById`, `getSpellKeyByName`, `getSpellNameById`, `getSpellNameByKey` | `isSpellId`, `isSpellKey`, `isSpellKeyNum`, `isSpellName`
-# Other
-| constants | types | type-validators
-| --- | --- | --- |
-`BuildingTypes`, `Continents`, `DataDragonUrls`, `DragonTypes`, `GameModes`, `GameTypes`, `KillTypes`, `Lanes`, `LaneTypes`, `Levels`, `Locales`, `MapIds`, `MonsterTypes`, `ParticipantIds`, `PlatformApiUris`, `PlatformIds`, `Positions`, `QueueDescriptions:`, `QueueIds`, `QueueTypes`, `RankedRanks`, `RankedTiers`, `RegionalApiUris`, `Regions`, `RelativeTeams`, `Roles`, `Skills`, `SkillSlots`, `TeamIds`, `TowerTypes`, `WardTypes` | `BuildingType`, `Continent`, `DragonType`, `GameMode`, `GameType`, `KillType`, `Lane`, `LaneType`, `Level`, `Locale`, `MapId`, `MonsterType`, `ParticipantId`, `PlatformApiUri`, `PlatformId`, `Position`, `QueueId`, `QueueType`, `RankedRank`, `RankedTier`, `RegionalApiUri`, `Region`, `RelativeTeam`, `Role`, `Skill`, `SkillSlot`, `TeamId`, `TowerType`, `WardType` | `isBuildingType`, `isContinent`, `isDragonType`, `isGameMode`, `isGameType`, `isKillType`, `isLane`, `isLaneType`, `isLevel`, `isLocale`, `isMapId`, `isMonsterType`, `isParticipantId`, `isPlatformApiUri`, `isPlatformId`, `getPlatformIdByRegion`, `isPosition`, `isQueueId`, `isQueueType`, `isRankedRank`, `isRankedTier`, `isRegionalApiUri`, `isRegion`, `getRegionByPlatformId`, `isRelativeTeam`, `isRole`, `isSkill`, `isSkillSlot`, `isTeamId`, `isTowerType`, `isWardType`
+# lol-constants
+Provides constants, helper functions, types (and type validator functions) for League of Legends game data, primarily in the context of [Riot API](https://developer.riotgames.com/docs/lol).
+
+In this library, you will find the main advantage to be: the ability to ‘convert’ between **Keys**, **IDs**, and **Names** of various game objects, namely champions, items, runes, and spells. Here's an example:
+
+```typescript
+import {lol, ChampionName} from 'lol-constants'
+
+let championName: ChampionName = 'Wukong'
+
+lol.champion.get(championName).id   // 62
+lol.champion.get(championName).key  // 'MonkeyKing'
+lol.champion.get(championName).name // 'Wukong'
+
+/* Alternatively... */
+
+import {getChampion} from 'lol-constants'
+
+getChampion(championName).id   // 62
+getChampion(championName).key  // 'MonkeyKing'
+getChampion(championName).name // 'Wukong'
+```
+
+That's not all. Such a getter function is also designed to be able to accept not only names, but also keys and ids. Here's how:
+
+```typescript
+import {getRune, RuneName, RuneKey, RuneId} from 'lol-constants'
+
+let runeName: RuneName = 'Cosmic Insight'
+let runeKey: RuneKey = 'CosmicInsight'
+let runeId: RuneId = 8347
+
+getRune(runeName) // ..
+getRune(runeKey) // ..
+getRune(runeId) // ..
+// All return the same rune object: {id: 8347, key: 'CosmicInsight', name: 'Cosmic Insight', ...}
+```
+
+This paradigm applies to **4** game areas: champions, items, runes (including stat runes and rune trees), and spells. Functions: `getChampion`, `getItem`, `getRune` (plus `getStatRune` and `getRuneTree`), and `getSpell`. Plus a few other areas.
+
+Constants
+---
+Whilst working with the Riot API, you will encounter many fields which have an exact type of value. As the library name suggests, these constants are a core part of it. So are their types and type validation functions which arise from each constant, like so:
+
+```typescript
+const DragonTypes = {...}
+type DragonType // "EARTH_DRAGON" | "CHEMTECH_DRAGON" | "AIR_DRAGON" | "HEXTECH_DRAGON" | "WATER_DRAGON" | "FIRE_DRAGON" | "ELDER_DRAGON"
+function isDragonType(type: string): type is DragonType {...}
+```
+See [actual code behind this constant](./src/constants/events.ts)\
+See [type validator usage example](./examples/type-validator-fn-example.ts)
+
+**Armed with these tools, you may effectively and fearlessly use types in your interfaces or elsewhere.**
+
+
+
+# Why the `lol` object?
+In part, it is meant to be an introductory entry point object for the library. You can explore all the different amenities this library provides without a hassle of looking for them outside of your code editor. When you have discovered a certain method, such as `lol.region.get`, you may start using its shorthand function, in this case `getRegion`. Additionally, you may look into the [examples file](./examples/examples-with-lol.ts) for all equivalents laid out.
+
+**Anything that you may find in the `lol` object can also be imported as a standalone constant, enum, or function.**
+
+
+
+# Key, ID, Name
+While the various JSONs provided by [DataDragon](https://developer.riotgames.com/docs/lol#data-dragon), such as [`champion.json`](http://ddragon.leagueoflegends.com/cdn/14.19.1/data/en_US/champion.json) or [`runesReforged.json`](http://ddragon.leagueoflegends.com/cdn/14.19.1/data/en_US/runesReforged.json) and so on, organize keys, ids, and names haphazardly, `lol-constants` offers a simpler approach that relies on the following principles:
+|     |     |
+| --- | --- |
+| **ID** | Numerical identifier *(primary entry point)* |
+| **Key** | Alias or reference *(secondary entry point)* |
+| **Name** | Display name of artifact *(user-friendly)* |
+
+Examples
+---
+
+| Category | ID | Key | Name |                                   `lol` getter | standalone |
+| ---:     | :---: | :---: | :---: |                            :--- | :--- |
+| Champion | `62` | `'MonkeyKing'` | `'Wukong'` |                `lol.champion.get` | `getChampion` |
+| Item     | `1038` | n/a | `'B. F. Sword'` |                      `lol.item.get` | `getItem` |
+| Rune      | `8347` | `'CosmicInsight'` | `'Cosmic Insight'` |  `lol.rune.get` | `getRune` |
+| Spell    | `4` | `'SummonerFlash'` | `'Flash'` |               `lol.spell.get` | `getSpell` |
+| ———— |  |  |  |
+| Stat Rune | `5008` | n/a | `'Adaptive Force'` |                  `lol.rune.stat.get` | `getStatRune` |
+| Rune Tree | `8000` | `'Precision'` | `'Precision'` |           `lol.rune.tree.get` | `getRuneTree` |
+
+
+
+# Types
+
+If you're working with TypeScript, you're gonna want types. Here are some useful types that are exported from the library:
+
+```typescript
+import {
+  // ### Basic constants
+  MonsterType,    // "HORDE" | "DRAGON" | "RIFTHERALD" | "BARON_NASHOR"
+  DragonType,     // "EARTH_DRAGON" | "CHEMTECH_DRAGON" | "AIR_DRAGON" | ...
+  KillType,       // "KILL_FIRST_BLOOD" | "KILL_MULTI" | "KILL_ACE"
+  BuildingType,   // "TOWER_BUILDING" | "INHIBITOR_BUILDING"
+  TowerType,      // "OUTER_TURRET" | "INNER_TURRET" | "BASE_TURRET" | "NEXUS_TURRET"
+  RankedTier,     // "CHALLENGER" | "GRANDMASTER" | "MASTER" | "DIAMOND" | ...
+  RankedRank,     // "I" | "II" | "III" | "IV"
+  Locale,         // "cs_CZ" | "el_GR" | "pl_PL" | "ro_RO" | "en_GB" | ...
+  Position,       // "TOP" | "JUNGLE" | "MIDDLE" | "BOTTOM" | "UTILITY"
+  // etc.
+  // ### Maps, Queues, Regions
+  QueueId,        // 0 | 420 | 2010 | 2020 | 400 | 430 | 440 | 450 | 700 | ...
+  Platform,       // "BR1" | "EUN1" | "EUW1" | "JP1" | "KR" | "LA1" | "LA2" | ...
+  Region,         // "BR" | "EUNE" | "EUW" | "JP" | "KR" | "LAN" | "LAS" | ...
+  // ### Champions, Items, Runes, Spells
+  ChampionId,     // 1 | 2 | 3 | 11 | 12 | 13 | 4 | 5 | 6 | 7 | 8 | 9 | ...
+  ChampionName,   // "Annie" | "Olaf" | "Galio" | "Twisted Fate" | "Xin Zhao" | ...
+  ItemId,         // 1001 | 1004 | 1006 | 1011 | 1018 | 1026 | 1027 | 1028 | ...
+  ItemName,       // "Boots" | "Faerie Charm" | "Rejuvenation Bead" | "Giant's Belt" | ...
+  RuneId,         // 8005 | 8021 | 8010 | 8009 | 9101 | 9111 | 8014 | 8017 | ...
+  RuneName,       // "Press the Attack" | "Presence of Mind" | "Conqueror" | ...
+  SpellId,        // 1 | 3 | 11 | 12 | 13 | 4 | 6 | 7 | 14 | 21 | 30 | 31 | ...
+  SpellName,      // "Cleanse" | "Exhaust" | "Flash" | "Ghost" | "Heal" | ...
+} from 'lol-constants'
+```
+
+More types can be found here: [examples/](./examples/)
+
+# Future plans
+Besides being an easy-to-update library with each League patch and to stay updated whenever a new patch does come out, there are several areas of interest for this library moving forward:
++ Provide tools (functions and such) for front-end work: getting icons and such.
++ Enable total backwards compatibility with older patches (i.e. no missing items or something for last couple of patches, preferably two years, which is the limit set by Riot API)
++ Fulfill any missing types and constants within the context of Riot API. Perhaps provide interfaces for Riot API responses.
++ More detailed champions, items, runes, and spells information. Would require using an own database of those instead of relying on DataDragon.
++ Optimized library size/splitting (currently library should be around ~100KB).
+
+So, why not give this library a star and see where it goes?

package/dist/Locale.d.ts

@@ -0,0 +1,2 @@
+import { Locale as ILocale } from './constants/locales';
+export declare const Locale: ILocale;

package/dist/Patch.d.ts

@@ -0,0 +1,3 @@
+export declare const Patch: {
+    readonly version: "14.19";
+};

package/dist/Patch.js

@@ -0,0 +1,3 @@
+export const Patch = {
+    version: '14.19',
+};

package/{core/constants/Champions/ChampionClasses.d.ts → dist/constants/custom.d.ts}

@@ -14,4 +14,4 @@ export declare const ChampionClasses: {
     readonly Specialist: "Specialist";
 };
 export type ChampionClass = typeof ChampionClasses[keyof typeof ChampionClasses];
-export declare function isChampionClass(value: any): value is ChampionClass;
+export declare function isChampionClass(title: string | null | undefined): title is ChampionClass;

package/{core/constants/Champions/ChampionClasses.js → dist/constants/custom.js}

@@ -20,6 +20,6 @@ export const ChampionClasses = {
     // # Specialist
     'Specialist': 'Specialist',
 };
-export function isChampionClass(value) {
-    return typeof value == 'string' && value in ChampionClasses;
+export function isChampionClass(title) {
+    return typeof title == 'string' && title in ChampionClasses;
 }

package/dist/constants/events.d.ts

@@ -0,0 +1,49 @@
+export declare const MonsterTypes: {
+    readonly HORDE: "HORDE";
+    readonly DRAGON: "DRAGON";
+    readonly RIFTHERALD: "RIFTHERALD";
+    readonly BARON_NASHOR: "BARON_NASHOR";
+};
+export type MonsterType = typeof MonsterTypes[keyof typeof MonsterTypes];
+export declare function isMonsterType(type: string | null | undefined): type is MonsterType;
+export declare const DragonTypes: {
+    readonly EARTH_DRAGON: "EARTH_DRAGON";
+    readonly CHEMTECH_DRAGON: "CHEMTECH_DRAGON";
+    readonly AIR_DRAGON: "AIR_DRAGON";
+    readonly HEXTECH_DRAGON: "HEXTECH_DRAGON";
+    readonly WATER_DRAGON: "WATER_DRAGON";
+    readonly FIRE_DRAGON: "FIRE_DRAGON";
+    readonly ELDER_DRAGON: "ELDER_DRAGON";
+};
+export type DragonType = typeof DragonTypes[keyof typeof DragonTypes];
+export declare function isDragonType(type: string | null | undefined): type is DragonType;
+export declare const KillTypes: {
+    readonly KILL_FIRST_BLOOD: "KILL_FIRST_BLOOD";
+    readonly KILL_MULTI: "KILL_MULTI";
+    readonly KILL_ACE: "KILL_ACE";
+};
+export type KillType = typeof KillTypes[keyof typeof KillTypes];
+export declare function isKillType(type: string | null | undefined): type is KillType;
+export declare const BuildingTypes: {
+    readonly TOWER_BUILDING: "TOWER_BUILDING";
+    readonly INHIBITOR_BUILDING: "INHIBITOR_BUILDING";
+};
+export type BuildingType = typeof BuildingTypes[keyof typeof BuildingTypes];
+export declare function isBuildingType(type: string | null | undefined): type is BuildingType;
+export declare const TowerTypes: {
+    readonly OUTER_TURRET: "OUTER_TURRET";
+    readonly INNER_TURRET: "INNER_TURRET";
+    readonly BASE_TURRET: "BASE_TURRET";
+    readonly NEXUS_TURRET: "NEXUS_TURRET";
+};
+export type TowerType = typeof TowerTypes[keyof typeof TowerTypes];
+export declare function isTowerType(type: string | null | undefined): type is TowerType;
+export declare const WardTypes: {
+    readonly UNDEFINED: "UNDEFINED";
+    readonly YELLOW_TRINKET: "YELLOW_TRINKET";
+    readonly CONTROL_WARD: "CONTROL_WARD";
+    readonly SIGHT_WARD: "SIGHT_WARD";
+    readonly BLUE_TRINKET: "BLUE_TRINKET";
+};
+export type WardType = typeof WardTypes[keyof typeof WardTypes];
+export declare function isWardType(type: string | null | undefined): type is WardType;

package/dist/constants/events.js

@@ -0,0 +1,55 @@
+export const MonsterTypes = {
+    'HORDE': 'HORDE',
+    'DRAGON': 'DRAGON',
+    'RIFTHERALD': 'RIFTHERALD',
+    'BARON_NASHOR': 'BARON_NASHOR',
+};
+export function isMonsterType(type) {
+    return typeof type == 'string' && type in MonsterTypes;
+}
+export const DragonTypes = {
+    'EARTH_DRAGON': 'EARTH_DRAGON',
+    'CHEMTECH_DRAGON': 'CHEMTECH_DRAGON',
+    'AIR_DRAGON': 'AIR_DRAGON',
+    'HEXTECH_DRAGON': 'HEXTECH_DRAGON',
+    'WATER_DRAGON': 'WATER_DRAGON',
+    'FIRE_DRAGON': 'FIRE_DRAGON',
+    'ELDER_DRAGON': 'ELDER_DRAGON',
+};
+export function isDragonType(type) {
+    return typeof type == 'string' && type in DragonTypes;
+}
+export const KillTypes = {
+    'KILL_FIRST_BLOOD': 'KILL_FIRST_BLOOD',
+    'KILL_MULTI': 'KILL_MULTI',
+    'KILL_ACE': 'KILL_ACE',
+};
+export function isKillType(type) {
+    return typeof type == 'string' && type in KillTypes;
+}
+export const BuildingTypes = {
+    'TOWER_BUILDING': 'TOWER_BUILDING',
+    'INHIBITOR_BUILDING': 'INHIBITOR_BUILDING',
+};
+export function isBuildingType(type) {
+    return typeof type == 'string' && type in BuildingTypes;
+}
+export const TowerTypes = {
+    'OUTER_TURRET': 'OUTER_TURRET',
+    'INNER_TURRET': 'INNER_TURRET',
+    'BASE_TURRET': 'BASE_TURRET',
+    'NEXUS_TURRET': 'NEXUS_TURRET',
+};
+export function isTowerType(type) {
+    return typeof type == 'string' && type in TowerTypes;
+}
+export const WardTypes = {
+    'UNDEFINED': 'UNDEFINED',
+    'YELLOW_TRINKET': 'YELLOW_TRINKET',
+    'CONTROL_WARD': 'CONTROL_WARD',
+    'SIGHT_WARD': 'SIGHT_WARD',
+    'BLUE_TRINKET': 'BLUE_TRINKET',
+};
+export function isWardType(type) {
+    return typeof type == 'string' && type in WardTypes;
+}

package/dist/constants/history.d.ts

@@ -0,0 +1,26 @@
+export declare const QueueTypes: {
+    readonly RANKED_SOLO_5x5: "RANKED_SOLO_5x5";
+    readonly RANKED_FLEX_SR: "RANKED_FLEX_SR";
+    readonly RANKED_TFT: "RANKED_TFT";
+};
+export type QueueType = typeof QueueTypes[keyof typeof QueueTypes];
+export declare function isQueueType(type: string | null | undefined): type is QueueType;
+export declare const GameModes: {
+    readonly CLASSIC: "CLASSIC";
+    readonly ARAM: "ARAM";
+    readonly TUTORIAL: "TUTORIAL";
+    readonly URF: "URF";
+    readonly ONEFORALL: "ONEFORALL";
+    readonly KINGPORO: "KINGPORO";
+    readonly GAMEMODEX: "GAMEMODEX";
+    readonly ULTBOOK: "ULTBOOK";
+};
+export type GameMode = typeof GameModes[keyof typeof GameModes];
+export declare function isGameMode(mode: string | null | undefined): mode is GameMode;
+export declare const GameTypes: {
+    readonly CUSTOM_GAME: "CUSTOM_GAME";
+    readonly TUTORIAL_GAME: "TUTORIAL_GAME";
+    readonly MATCHED_GAME: "MATCHED_GAME";
+};
+export type GameType = typeof GameTypes[keyof typeof GameTypes];
+export declare function isGameType(type: string | null | undefined): type is GameType;

package/dist/constants/history.js

@@ -0,0 +1,29 @@
+export const QueueTypes = {
+    'RANKED_SOLO_5x5': 'RANKED_SOLO_5x5',
+    'RANKED_FLEX_SR': 'RANKED_FLEX_SR',
+    'RANKED_TFT': 'RANKED_TFT',
+};
+export function isQueueType(type) {
+    return typeof type == 'string' && type in QueueTypes;
+}
+export const GameModes = {
+    'CLASSIC': 'CLASSIC',
+    'ARAM': 'ARAM',
+    'TUTORIAL': 'TUTORIAL',
+    'URF': 'URF',
+    'ONEFORALL': 'ONEFORALL',
+    'KINGPORO': 'KINGPORO',
+    'GAMEMODEX': 'GAMEMODEX',
+    'ULTBOOK': 'ULTBOOK',
+};
+export function isGameMode(mode) {
+    return typeof mode == 'string' && mode in GameModes;
+}
+export const GameTypes = {
+    'CUSTOM_GAME': 'CUSTOM_GAME',
+    'TUTORIAL_GAME': 'TUTORIAL_GAME',
+    'MATCHED_GAME': 'MATCHED_GAME',
+};
+export function isGameType(type) {
+    return typeof type == 'string' && type in GameTypes;
+}

package/{core/constants/RankedTiers.d.ts → dist/constants/leagues.d.ts}

@@ -11,4 +11,12 @@ export declare const RankedTiers: {
     readonly IRON: "IRON";
 };
 export type RankedTier = typeof RankedTiers[keyof typeof RankedTiers];
-export declare function isRankedTier(value: any): value is RankedTier;
+export declare function isRankedTier(tier: string | null | undefined): tier is RankedTier;
+export declare const RankedRanks: {
+    readonly I: "I";
+    readonly II: "II";
+    readonly III: "III";
+    readonly IV: "IV";
+};
+export type RankedRank = typeof RankedRanks[keyof typeof RankedRanks];
+export declare function isRankedRank(rank: string | null | undefined): rank is RankedRank;

package/{core/constants/RankedTiers.js → dist/constants/leagues.js}

@@ -10,6 +10,15 @@ export const RankedTiers = {
     'BRONZE': 'BRONZE',
     'IRON': 'IRON',
 };
-export function isRankedTier(value) {
-    return typeof value == 'string' && value in RankedTiers;
+export function isRankedTier(tier) {
+    return typeof tier == 'string' && tier in RankedTiers;
+}
+export const RankedRanks = {
+    'I': 'I',
+    'II': 'II',
+    'III': 'III',
+    'IV': 'IV',
+};
+export function isRankedRank(rank) {
+    return typeof rank == 'string' && rank in RankedRanks;
 }

package/{core/constants/Locales.d.ts → dist/constants/locales.d.ts}

@@ -57,4 +57,4 @@ export declare const Locales: {
     readonly zh_TW: "zh_TW";
 };
 export type Locale = typeof Locales[keyof typeof Locales];
-export declare function isLocale(value: any): value is Locale;
+export declare function isLocale(locale: string | null | undefined): locale is Locale;

package/{core/constants/Locales.js → dist/constants/locales.js}

@@ -56,6 +56,6 @@ export const Locales = {
     /** Chinese (Taiwan) */
     'zh_TW': 'zh_TW',
 };
-export function isLocale(value) {
-    return typeof value == 'string' && value in Locales;
+export function isLocale(locale) {
+    return typeof locale == 'string' && locale in Locales;
 }

package/dist/constants/participants.d.ts

@@ -0,0 +1,38 @@
+export declare const Positions: {
+    readonly TOP: "TOP";
+    readonly JUNGLE: "JUNGLE";
+    readonly MIDDLE: "MIDDLE";
+    readonly BOTTOM: "BOTTOM";
+    readonly UTILITY: "UTILITY";
+};
+export type Position = typeof Positions[keyof typeof Positions];
+export declare function isPosition(position: string | null | undefined): position is Position;
+export declare const Roles: {
+    readonly NONE: "NONE";
+    readonly SOLO: "SOLO";
+    readonly CARRY: "CARRY";
+    readonly SUPPORT: "SUPPORT";
+};
+export type Role = typeof Roles[keyof typeof Roles];
+export declare function isRole(role: string | null | undefined): role is Role;
+export declare const Lanes: {
+    readonly TOP: "TOP";
+    readonly JUNGLE: "JUNGLE";
+    readonly MIDDLE: "MIDDLE";
+    readonly BOTTOM: "BOTTOM";
+};
+export type Lane = typeof Lanes[keyof typeof Lanes];
+export declare function isLane(lane: string | null | undefined): lane is Lane;
+export declare const LaneTypes: {
+    readonly TOP_LANE: "TOP_LANE";
+    readonly MID_LANE: "MID_LANE";
+    readonly BOT_LANE: "BOT_LANE";
+};
+export type LaneType = typeof LaneTypes[keyof typeof LaneTypes];
+export declare function isLaneType(type: string | null | undefined): type is LaneType;
+export declare const TeamIds: {
+    readonly 100: 100;
+    readonly 200: 200;
+};
+export type TeamId = typeof TeamIds[keyof typeof TeamIds];
+export declare function isTeamId(id: number | null | undefined): id is TeamId;

package/dist/constants/participants.js

@@ -0,0 +1,43 @@
+export const Positions = {
+    'TOP': 'TOP',
+    'JUNGLE': 'JUNGLE',
+    'MIDDLE': 'MIDDLE',
+    'BOTTOM': 'BOTTOM',
+    'UTILITY': 'UTILITY',
+};
+export function isPosition(position) {
+    return typeof position == 'string' && position in Positions;
+}
+export const Roles = {
+    'NONE': 'NONE',
+    'SOLO': 'SOLO',
+    'CARRY': 'CARRY',
+    'SUPPORT': 'SUPPORT',
+};
+export function isRole(role) {
+    return typeof role == 'string' && role in Roles;
+}
+export const Lanes = {
+    'TOP': 'TOP',
+    'JUNGLE': 'JUNGLE',
+    'MIDDLE': 'MIDDLE',
+    'BOTTOM': 'BOTTOM',
+};
+export function isLane(lane) {
+    return typeof lane == 'string' && lane in Lanes;
+}
+export const LaneTypes = {
+    'TOP_LANE': 'TOP_LANE',
+    'MID_LANE': 'MID_LANE',
+    'BOT_LANE': 'BOT_LANE',
+};
+export function isLaneType(type) {
+    return typeof type == 'string' && type in LaneTypes;
+}
+export const TeamIds = {
+    100: 100,
+    200: 200,
+};
+export function isTeamId(id) {
+    return typeof id == 'number' && id in TeamIds;
+}

package/dist/enums/ItemSrTypes.d.ts

@@ -0,0 +1,11 @@
+export declare const ItemSrTypes: {
+    readonly STARTER: 0;
+    readonly BASIC: 1;
+    readonly EPIC: 2;
+    readonly LEGENDARY: 3;
+    readonly TRINKET: 11;
+    readonly BOOTS: 12;
+    readonly CONSUMABLE: 13;
+    readonly MISC: -1;
+};
+export type ItemSrType = typeof ItemSrTypes[keyof typeof ItemSrTypes];

package/dist/enums/ItemSrTypes.js

@@ -0,0 +1,10 @@
+export const ItemSrTypes = {
+    STARTER: 0,
+    BASIC: 1,
+    EPIC: 2,
+    LEGENDARY: 3,
+    TRINKET: 11,
+    BOOTS: 12,
+    CONSUMABLE: 13,
+    MISC: -1,
+};

package/dist/enums/StatRuneSlots.d.ts

@@ -0,0 +1,6 @@
+export declare const StatRuneSlots: {
+    readonly OFFENSE: 0;
+    readonly FLEX: 1;
+    readonly DEFENSE: 2;
+};
+export type StatRuneSlot = typeof StatRuneSlots[keyof typeof StatRuneSlots];

package/dist/enums/StatRuneSlots.js

@@ -0,0 +1,5 @@
+export const StatRuneSlots = {
+    OFFENSE: 0,
+    FLEX: 1,
+    DEFENSE: 2,
+};